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

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

@@ -1,306 +0,0 @@
-import { mock } from 'jest-mock-extended';
-import { UpdateIssueStatusByLabelUseCase } from './UpdateIssueStatusByLabelUseCase';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { Issue } from '../entities/Issue';
-import { FieldOption, Project } from '../entities/Project';
-
-describe('UpdateIssueStatusByLabelUseCase', () => {
-  const mockIssueRepository = mock<IssueRepository>();
-
-  const mockTodoStatus = mock<FieldOption>();
-  mockTodoStatus.id = 'status1';
-  mockTodoStatus.name = 'ToDo';
-
-  const mockInProgressStatus = mock<FieldOption>();
-  mockInProgressStatus.id = 'status2';
-  mockInProgressStatus.name = 'In Progress';
-
-  const mockIceboxStatus = mock<FieldOption>();
-  mockIceboxStatus.id = 'status3';
-  mockIceboxStatus.name = 'Icebox';
-
-  const basicProject = {
-    ...mock<Project>(),
-    status: {
-      name: 'Status Field',
-      fieldId: 'statusFieldId',
-      statuses: [mockTodoStatus, mockInProgressStatus, mockIceboxStatus],
-    },
-  };
-
-  let useCase: UpdateIssueStatusByLabelUseCase;
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    useCase = new UpdateIssueStatusByLabelUseCase(mockIssueRepository);
-  });
-
-  describe('normalizeStatus', () => {
-    const testCases: {
-      name: string;
-      input: string;
-      expected: string;
-    }[] = [
-      {
-        name: 'should remove spaces',
-        input: 'In Progress',
-        expected: 'inprogress',
-      },
-      {
-        name: 'should remove hyphens',
-        input: 'in-progress',
-        expected: 'inprogress',
-      },
-      {
-        name: 'should remove underscores',
-        input: 'in_progress',
-        expected: 'inprogress',
-      },
-      {
-        name: 'should convert to lowercase',
-        input: 'IN PROGRESS',
-        expected: 'inprogress',
-      },
-      {
-        name: 'should handle mixed separators',
-        input: 'In-Progress_Now',
-        expected: 'inprogressnow',
-      },
-      {
-        name: 'should handle no separators',
-        input: 'todo',
-        expected: 'todo',
-      },
-    ];
-
-    testCases.forEach(({ name, input, expected }) => {
-      it(name, () => {
-        expect(UpdateIssueStatusByLabelUseCase.normalizeStatus(input)).toEqual(
-          expected,
-        );
-      });
-    });
-  });
-
-  describe('run', () => {
-    const testCases: {
-      name: string;
-      issues: Issue[];
-      expectedCalls: {
-        updateStatus: [unknown, unknown, string][];
-        removeLabel: [unknown, string][];
-      };
-    }[] = [
-      {
-        name: 'should not update when no issues have status label',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['bug', 'priority-high'],
-            status: 'ToDo',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [],
-          removeLabel: [],
-        },
-      },
-      {
-        name: 'should update status and remove label when status differs',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['bug', 'status:In Progress'],
-            status: 'ToDo',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [[expect.anything(), expect.anything(), 'status2']],
-          removeLabel: [[expect.anything(), 'status:In Progress']],
-        },
-      },
-      {
-        name: 'should remove label without updating when status already matches',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['status:ToDo'],
-            status: 'ToDo',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [],
-          removeLabel: [[expect.anything(), 'status:ToDo']],
-        },
-      },
-      {
-        name: 'should match status ignoring whitespace, hyphens, and underscores',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['status:in-progress'],
-            status: 'In Progress',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [],
-          removeLabel: [[expect.anything(), 'status:in-progress']],
-        },
-      },
-      {
-        name: 'should match status ignoring underscores',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['status:in_progress'],
-            status: 'In Progress',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [],
-          removeLabel: [[expect.anything(), 'status:in_progress']],
-        },
-      },
-      {
-        name: 'should skip when target status is not found in project statuses',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['status:Unknown Status'],
-            status: 'ToDo',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [],
-          removeLabel: [],
-        },
-      },
-      {
-        name: 'should handle multiple issues with status labels',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['status:In Progress'],
-            status: 'ToDo',
-          },
-          {
-            ...mock<Issue>(),
-            labels: ['status:Icebox'],
-            status: 'ToDo',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [
-            [expect.anything(), expect.anything(), 'status2'],
-            [expect.anything(), expect.anything(), 'status3'],
-          ],
-          removeLabel: [
-            [expect.anything(), 'status:In Progress'],
-            [expect.anything(), 'status:Icebox'],
-          ],
-        },
-      },
-      {
-        name: 'should handle case-insensitive label prefix',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['Status:Icebox'],
-            status: 'ToDo',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [[expect.anything(), expect.anything(), 'status3']],
-          removeLabel: [[expect.anything(), 'Status:Icebox']],
-        },
-      },
-      {
-        name: 'should update status when issue has null status',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['status:ToDo'],
-            status: null,
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [[expect.anything(), expect.anything(), 'status1']],
-          removeLabel: [[expect.anything(), 'status:ToDo']],
-        },
-      },
-      {
-        name: 'should process only the first status label found',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['status:In Progress', 'status:Icebox'],
-            status: 'ToDo',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [[expect.anything(), expect.anything(), 'status2']],
-          removeLabel: [[expect.anything(), 'status:In Progress']],
-        },
-      },
-      {
-        name: 'should handle empty issues array',
-        issues: [],
-        expectedCalls: {
-          updateStatus: [],
-          removeLabel: [],
-        },
-      },
-      {
-        name: 'should not update when status label value does not match any project status',
-        issues: [
-          {
-            ...mock<Issue>(),
-            labels: ['status:UnknownStatus'],
-            status: 'ToDo',
-          },
-        ],
-        expectedCalls: {
-          updateStatus: [],
-          removeLabel: [],
-        },
-      },
-    ];
-
-    testCases.forEach(({ name, issues, expectedCalls }) => {
-      it(name, async () => {
-        await useCase.run({
-          project: basicProject,
-          issues,
-        });
-
-        expect(mockIssueRepository.updateStatus.mock.calls).toEqual(
-          expectedCalls.updateStatus,
-        );
-        expect(mockIssueRepository.removeLabel.mock.calls).toEqual(
-          expectedCalls.removeLabel,
-        );
-      });
-    });
-
-    it('should include issue url and label in error message when removeLabel fails', async () => {
-      const issueWithUrl = {
-        ...mock<Issue>(),
-        labels: ['status:In Progress'],
-        status: 'In Progress',
-        url: 'https://github.com/testOrg/testRepo/issues/42',
-      };
-      mockIssueRepository.removeLabel.mockRejectedValueOnce(
-        new Error('Request failed with status code 403 Forbidden'),
-      );
-
-      await expect(
-        useCase.run({
-          project: basicProject,
-          issues: [issueWithUrl],
-        }),
-      ).rejects.toThrow(
-        'Failed to remove label status:In Progress from issue https://github.com/testOrg/testRepo/issues/42: Request failed with status code 403 Forbidden',
-      );
-    });
-  });
-});

package/src/domain/usecases/UpdateIssueStatusByLabelUseCase.ts

@@ -1,64 +0,0 @@
-import { Issue } from '../entities/Issue';
-import { Project } from '../entities/Project';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-
-export class UpdateIssueStatusByLabelUseCase {
-  constructor(
-    readonly issueRepository: Pick<
-      IssueRepository,
-      'updateStatus' | 'removeLabel'
-    >,
-  ) {}
-
-  static readonly STATUS_LABEL_PREFIX = 'status:';
-
-  static normalizeStatus = (status: string): string =>
-    status.toLowerCase().replace(/[\s\-_]/g, '');
-
-  run = async (input: { project: Project; issues: Issue[] }): Promise<void> => {
-    for (const issue of input.issues) {
-      const statusLabel = issue.labels.find((label) =>
-        label
-          .toLowerCase()
-          .startsWith(UpdateIssueStatusByLabelUseCase.STATUS_LABEL_PREFIX),
-      );
-      if (!statusLabel) {
-        continue;
-      }
-      const targetStatusName = statusLabel.slice(
-        UpdateIssueStatusByLabelUseCase.STATUS_LABEL_PREFIX.length,
-      );
-      const targetStatus = input.project.status.statuses.find(
-        (s) =>
-          UpdateIssueStatusByLabelUseCase.normalizeStatus(s.name) ===
-          UpdateIssueStatusByLabelUseCase.normalizeStatus(targetStatusName),
-      );
-      if (!targetStatus) {
-        continue;
-      }
-      const currentStatusNormalized = issue.status
-        ? UpdateIssueStatusByLabelUseCase.normalizeStatus(issue.status)
-        : null;
-      const targetStatusNormalized =
-        UpdateIssueStatusByLabelUseCase.normalizeStatus(targetStatus.name);
-      if (currentStatusNormalized !== targetStatusNormalized) {
-        await this.issueRepository.updateStatus(
-          input.project,
-          issue,
-          targetStatus.id,
-        );
-      }
-      try {
-        await this.issueRepository.removeLabel(issue, statusLabel);
-      } catch (e) {
-        if (!(e instanceof Error)) {
-          throw e;
-        }
-        throw new Error(
-          `Failed to remove label ${statusLabel} from issue ${issue.url}: ${e.message}`,
-          { cause: e },
-        );
-      }
-    }
-  };
-}

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

@@ -1,178 +0,0 @@
-import { UpdateRateLimitCacheUseCase } from './UpdateRateLimitCacheUseCase';
-import { mock } from 'jest-mock-extended';
-import { RateLimitCacheRepository } from './adapter-interfaces/RateLimitCacheRepository';
-
-describe('UpdateRateLimitCacheUseCase', () => {
-  const mockRateLimitCacheRepository = mock<RateLimitCacheRepository>();
-
-  const useCase = new UpdateRateLimitCacheUseCase(mockRateLimitCacheRepository);
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should probe a token whose unifiedReset is in the past', async () => {
-    const nowEpochSeconds = 1000000100;
-    const pastReset = 1000000000;
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([
-      {
-        token: 'token-expired',
-        unifiedReset: pastReset,
-        lastProbeEpoch: nowEpochSeconds,
-      },
-    ]);
-    mockRateLimitCacheRepository.probeToken.mockResolvedValue(undefined);
-
-    await useCase.run({ nowEpochSeconds });
-
-    expect(mockRateLimitCacheRepository.probeToken).toHaveBeenCalledWith(
-      'token-expired',
-    );
-  });
-
-  it('should not probe a token whose unifiedReset is in the future and was probed within the last hour', async () => {
-    const nowEpochSeconds = 1000000000;
-    const futureReset = nowEpochSeconds + 1800;
-    const tenMinutesAgo = nowEpochSeconds - 600;
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([
-      {
-        token: 'token-active',
-        unifiedReset: futureReset,
-        lastProbeEpoch: tenMinutesAgo,
-      },
-    ]);
-
-    await useCase.run({ nowEpochSeconds });
-
-    expect(mockRateLimitCacheRepository.probeToken).not.toHaveBeenCalled();
-  });
-
-  it('should probe only tokens with expired reset when mixed tokens exist', async () => {
-    const nowEpochSeconds = 1000000100;
-    const pastReset = 1000000000;
-    const futureReset = nowEpochSeconds + 1800;
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([
-      {
-        token: 'token-expired',
-        unifiedReset: pastReset,
-        lastProbeEpoch: nowEpochSeconds,
-      },
-      {
-        token: 'token-active',
-        unifiedReset: futureReset,
-        lastProbeEpoch: nowEpochSeconds,
-      },
-    ]);
-    mockRateLimitCacheRepository.probeToken.mockResolvedValue(undefined);
-
-    await useCase.run({ nowEpochSeconds });
-
-    expect(mockRateLimitCacheRepository.probeToken).toHaveBeenCalledTimes(1);
-    expect(mockRateLimitCacheRepository.probeToken).toHaveBeenCalledWith(
-      'token-expired',
-    );
-  });
-
-  it('should update the cache after probing by relying on the repository side effect', async () => {
-    const nowEpochSeconds = 1000000100;
-    const pastReset = 1000000000;
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([
-      {
-        token: 'token-expired',
-        unifiedReset: pastReset,
-        lastProbeEpoch: nowEpochSeconds,
-      },
-    ]);
-    mockRateLimitCacheRepository.probeToken.mockResolvedValue(undefined);
-
-    await useCase.run({ nowEpochSeconds });
-
-    expect(mockRateLimitCacheRepository.probeToken).toHaveBeenCalledWith(
-      'token-expired',
-    );
-  });
-
-  it('should handle an empty token list without errors', async () => {
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([]);
-
-    await useCase.run({ nowEpochSeconds: 1000000000 });
-
-    expect(mockRateLimitCacheRepository.probeToken).not.toHaveBeenCalled();
-  });
-
-  it('should probe a token whose last probe was 61 minutes ago even when unifiedReset is in the future', async () => {
-    const nowEpochSeconds = 1000000000;
-    const futureReset = nowEpochSeconds + 7200;
-    const sixtyOneMinutesAgo = nowEpochSeconds - 61 * 60;
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([
-      {
-        token: 'token-stale-probe',
-        unifiedReset: futureReset,
-        lastProbeEpoch: sixtyOneMinutesAgo,
-      },
-    ]);
-    mockRateLimitCacheRepository.probeToken.mockResolvedValue(undefined);
-
-    await useCase.run({ nowEpochSeconds });
-
-    expect(mockRateLimitCacheRepository.probeToken).toHaveBeenCalledWith(
-      'token-stale-probe',
-    );
-  });
-
-  it('should not probe a token whose last probe was 10 minutes ago', async () => {
-    const nowEpochSeconds = 1000000000;
-    const futureReset = nowEpochSeconds + 7200;
-    const tenMinutesAgo = nowEpochSeconds - 10 * 60;
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([
-      {
-        token: 'token-fresh-probe',
-        unifiedReset: futureReset,
-        lastProbeEpoch: tenMinutesAgo,
-      },
-    ]);
-
-    await useCase.run({ nowEpochSeconds });
-
-    expect(mockRateLimitCacheRepository.probeToken).not.toHaveBeenCalled();
-  });
-
-  it('should probe a token with unifiedReset in the past regardless of last probe time', async () => {
-    const nowEpochSeconds = 1000000000;
-    const pastReset = nowEpochSeconds - 60;
-    const oneMinuteAgo = nowEpochSeconds - 60;
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([
-      {
-        token: 'token-expired-recent-probe',
-        unifiedReset: pastReset,
-        lastProbeEpoch: oneMinuteAgo,
-      },
-    ]);
-    mockRateLimitCacheRepository.probeToken.mockResolvedValue(undefined);
-
-    await useCase.run({ nowEpochSeconds });
-
-    expect(mockRateLimitCacheRepository.probeToken).toHaveBeenCalledWith(
-      'token-expired-recent-probe',
-    );
-  });
-
-  it('should probe a token that has never been probed even when unifiedReset is in the future', async () => {
-    const nowEpochSeconds = 1000000000;
-    const futureReset = nowEpochSeconds + 7200;
-    mockRateLimitCacheRepository.getTokenRateLimitCaches.mockReturnValue([
-      {
-        token: 'token-never-probed',
-        unifiedReset: futureReset,
-        lastProbeEpoch: 0,
-      },
-    ]);
-    mockRateLimitCacheRepository.probeToken.mockResolvedValue(undefined);
-
-    await useCase.run({ nowEpochSeconds });
-
-    expect(mockRateLimitCacheRepository.probeToken).toHaveBeenCalledWith(
-      'token-never-probed',
-    );
-  });
-});

package/src/domain/usecases/UpdateRateLimitCacheUseCase.ts

@@ -1,22 +0,0 @@
-import { RateLimitCacheRepository } from './adapter-interfaces/RateLimitCacheRepository';
-
-const HOURLY_PROBE_INTERVAL_SECONDS = 3600;
-
-export class UpdateRateLimitCacheUseCase {
-  constructor(
-    private readonly rateLimitCacheRepository: RateLimitCacheRepository,
-  ) {}
-
-  run = async (params: { nowEpochSeconds: number }): Promise<void> => {
-    const caches = this.rateLimitCacheRepository.getTokenRateLimitCaches();
-    for (const cache of caches) {
-      const unifiedResetExpired = cache.unifiedReset < params.nowEpochSeconds;
-      const hourlyProbeDue =
-        params.nowEpochSeconds - cache.lastProbeEpoch >=
-        HOURLY_PROBE_INTERVAL_SECONDS;
-      if (unifiedResetExpired || hourlyProbeDue) {
-        await this.rateLimitCacheRepository.probeToken(cache.token);
-      }
-    }
-  };
-}

package/src/domain/usecases/adapter-interfaces/ClaudeHandoverSessionRepository.ts

@@ -1,5 +0,0 @@
-import { ClaudeHandoverSession } from '../../entities/ClaudeHandoverSession';
-
-export interface ClaudeHandoverSessionRepository {
-  listHandoverSessions: () => ClaudeHandoverSession[];
-}

package/src/domain/usecases/adapter-interfaces/ClaudeInteractiveSessionRepository.ts

@@ -1,9 +0,0 @@
-export type ClaudeInteractiveSession = {
-  token: string;
-  sessionId: string;
-  issueUrl: string;
-};
-
-export interface ClaudeInteractiveSessionRepository {
-  listInteractiveSessions: () => ClaudeInteractiveSession[];
-}

package/src/domain/usecases/adapter-interfaces/ClaudeLiveSessionRepository.ts

@@ -1,8 +0,0 @@
-export type ClaudeLiveSession = {
-  token: string;
-  sessionKey: string;
-};
-
-export interface ClaudeLiveSessionRepository {
-  listLiveSessions: () => ClaudeLiveSession[];
-}

package/src/domain/usecases/adapter-interfaces/ClaudeMessageResponseRepository.ts

@@ -1,5 +0,0 @@
-import { ClaudeMessageResponse } from '../../entities/ClaudeMessageResponse';
-
-export interface ClaudeMessageResponseRepository {
-  append: (response: ClaudeMessageResponse) => void;
-}

package/src/domain/usecases/adapter-interfaces/ClaudeRepository.ts

@@ -1,6 +0,0 @@
-import { ClaudeWindowUsage } from '../../entities/ClaudeWindowUsage';
-
-export interface ClaudeRepository {
-  getUsage(): Promise<ClaudeWindowUsage[]>;
-  isClaudeAvailable(threshold: number): Promise<boolean>;
-}

package/src/domain/usecases/adapter-interfaces/ClaudeTokenUsageRepository.ts

@@ -1,8 +0,0 @@
-import { ClaudeTokenUsage } from '../../entities/ClaudeTokenUsage';
-
-export interface ClaudeTokenUsageRepository {
-  ensureObservable(): Promise<void>;
-  getAvailableTokenUsages(): Promise<ClaudeTokenUsage[]>;
-  getTokenInFlightCounts(): Promise<Record<string, number>>;
-  proxyBaseUrl(): string;
-}

package/src/domain/usecases/adapter-interfaces/ConsoleTabsRepository.ts

@@ -1,12 +0,0 @@
-import {
-  ConsoleListItem,
-  ConsoleTabName,
-} from '../console/GenerateConsoleListsUseCase';
-
-export interface ConsoleTabsRepository {
-  patchIssueTabTransition(params: {
-    projectItemId: string;
-    item: ConsoleListItem;
-    targetTabName: ConsoleTabName | null;
-  }): void;
-}

package/src/domain/usecases/adapter-interfaces/CopilotRepository.ts

@@ -1,3 +0,0 @@
-export interface CopilotRepository {
-  run(prompt: string, model: 'gpt-5-mini', processTitle: string): void;
-}

package/src/domain/usecases/adapter-interfaces/DateRepository.ts

@@ -1,7 +0,0 @@
-export interface DateRepository {
-  now(): Promise<Date>;
-  formatDurationToHHMM(durationMinutes: number): string;
-  formatDateTimeWithDayOfWeek(date: Date): string;
-  formatDateWithDayOfWeek(date: Date): string;
-  formatStartEnd(startedAt: Date, endedAt: Date): string;
-}

package/src/domain/usecases/adapter-interfaces/GitHubGraphqlRateLimitRepository.ts

@@ -1,3 +0,0 @@
-export interface GitHubGraphqlRateLimitRepository {
-  getRemainingRequestCount(): Promise<number | null>;
-}

package/src/domain/usecases/adapter-interfaces/HttpRepository.ts

@@ -1,3 +0,0 @@
-export interface HttpRepository {
-  get: (url: string) => Promise<string>;
-}

package/src/domain/usecases/adapter-interfaces/InteractiveLiveSessionTranscriptResolver.ts

@@ -1,7 +0,0 @@
-import { InteractiveLiveSession } from '../../entities/InteractiveLiveSession';
-
-export interface InteractiveLiveSessionTranscriptResolver {
-  resolveTranscriptPaths: (
-    sessions: InteractiveLiveSession[],
-  ) => Map<string, string>;
-}

package/src/domain/usecases/adapter-interfaces/IssueAttachmentRepository.ts

@@ -1,9 +0,0 @@
-export type IssueAttachmentUploadRequest = {
-  issueOrPullRequestUrl: string;
-  fileName: string;
-  content: Uint8Array;
-};
-
-export interface IssueAttachmentRepository {
-  uploadAttachment(request: IssueAttachmentUploadRequest): Promise<string>;
-}

package/src/domain/usecases/adapter-interfaces/IssueCheckpointRepository.ts

@@ -1,3 +0,0 @@
-export interface IssueCheckpointRepository {
-  postCheckpoint(issueUrl: string): Promise<void>;
-}