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

package/src/domain/usecases/ActionAnnouncementUseCase.ts

@@ -1,78 +0,0 @@
-import { Issue } from '../entities/Issue';
-import { Member } from '../entities/Member';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { Project } from '../entities/Project';
-
-export class ActionAnnouncementUseCase {
-  constructor(
-    readonly issueRepository: Pick<
-      IssueRepository,
-      'createNewIssue' | 'updateIssue'
-    >,
-  ) {}
-
-  run = async (input: {
-    targetDates: Date[];
-    project: Project;
-    issues: Issue[];
-    cacheUsed: boolean;
-    members: Member['name'][];
-    manager: Member['name'];
-  }): Promise<void> => {
-    if (input.cacheUsed || input.targetDates.length === 0) {
-      return;
-    }
-    const now = input.targetDates[input.targetDates.length - 1];
-    const isTargetIssue = (issue: Issue): boolean => {
-      return (
-        issue.labels.includes('action:announcement') &&
-        (issue.nextActionDate === null ||
-          issue.nextActionDate.getTime() <= now.getTime()) &&
-        issue.state === 'OPEN'
-      );
-    };
-    const actionAnnouncementIssues = input.issues.filter((issue) =>
-      isTargetIssue(issue),
-    );
-    for (const issue of actionAnnouncementIssues) {
-      for (const member of input.members) {
-        try {
-          await this.issueRepository.createNewIssue(
-            issue.org,
-            issue.repo,
-            `Announcement #${issue.number}: ${issue.title} / ${member}`,
-            `From: :robot: ActionAnnouncementUseCase
-
-Hi @${member},
-
-Please take a look at the announcement in the issue ${issue.url} and take necessary actions :pray:
-`,
-            [member],
-            [
-              ...issue.labels.filter(
-                (label) => label !== 'action:announcement',
-              ),
-              'story:workflow-management',
-            ],
-          );
-        } catch (e) {
-          await this.issueRepository.createNewIssue(
-            issue.org,
-            issue.repo,
-            `Error occured while creating working report for ${member}`,
-            `From: :robot: ActionAnnouncementUseCase\n\n${JSON.stringify(e)}`,
-            [input.manager],
-            ['bug'],
-          );
-        }
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-      }
-      await this.issueRepository.updateIssue({
-        ...issue,
-        labels: issue.labels
-          .filter((label) => label !== 'action:announcement')
-          .concat('announcement'),
-      });
-    }
-  };
-}

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

@@ -1,222 +0,0 @@
-import { AgentDesignationLabelAdoptUseCase } from './AgentDesignationLabelAdoptUseCase';
-import { Issue } from '../entities/Issue';
-import { Project } from '../entities/Project';
-
-const createIssue = (overrides: Partial<Issue> = {}): Issue => ({
-  nameWithOwner: 'user/repo',
-  number: 1,
-  title: 'Test issue',
-  state: 'OPEN',
-  status: 'Preparation',
-  story: null,
-  nextActionDate: null,
-  nextActionHour: null,
-  estimationMinutes: null,
-  dependedIssueUrls: [],
-  completionDate50PercentConfidence: null,
-  url: 'https://github.com/user/repo/issues/1',
-  assignees: [],
-  labels: [],
-  org: 'user',
-  repo: 'repo',
-  body: '',
-  itemId: 'item1',
-  isPr: false,
-  isInProgress: false,
-  isClosed: false,
-  createdAt: new Date('2024-01-01T00:00:00Z'),
-  author: 'author',
-  closingIssueReferenceUrls: [],
-  agent: null,
-  stateReason: null,
-  ...overrides,
-});
-
-const createProject = (
-  agentOptions: { id: string; name: string }[] = [],
-): Project => ({
-  id: 'project1',
-  url: 'https://github.com/orgs/user/projects/1',
-  databaseId: 1,
-  name: 'Test Project',
-  status: { name: 'Status', fieldId: 'field1', statuses: [] },
-  nextActionDate: null,
-  nextActionHour: null,
-  story: null,
-  remainingEstimationMinutes: null,
-  dependedIssueUrlSeparatedByComma: null,
-  completionDate50PercentConfidence: null,
-  agent:
-    agentOptions.length > 0
-      ? {
-          name: 'Agent',
-          fieldId: 'agent-field',
-          options: agentOptions.map((o) => ({
-            id: o.id,
-            name: o.name,
-            color: 'GRAY' as const,
-            description: '',
-          })),
-        }
-      : null,
-});
-
-describe('AgentDesignationLabelAdoptUseCase', () => {
-  let mockProjectRepository: {
-    getByUrl: jest.Mock;
-    createField: jest.Mock;
-    updateAgentList: jest.Mock;
-  };
-  let mockIssueRepository: {
-    setIssueAgentField: jest.Mock;
-    removeLabel: jest.Mock;
-  };
-  let useCase: AgentDesignationLabelAdoptUseCase;
-
-  beforeEach(() => {
-    jest.resetAllMocks();
-    mockProjectRepository = {
-      getByUrl: jest.fn(),
-      createField: jest.fn().mockResolvedValue(undefined),
-      updateAgentList: jest.fn().mockResolvedValue([]),
-    };
-    mockIssueRepository = {
-      setIssueAgentField: jest.fn().mockResolvedValue(undefined),
-      removeLabel: jest.fn().mockResolvedValue(undefined),
-    };
-    useCase = new AgentDesignationLabelAdoptUseCase(
-      mockProjectRepository,
-      mockIssueRepository,
-    );
-  });
-
-  it('should set the Agent field and remove the label for an open non-spawn-candidate item carrying a label matching a configured agent name', async () => {
-    const project = createProject([{ id: 'option-chore-id', name: 'chore' }]);
-    const issue = createIssue({
-      labels: ['chore'],
-      agent: null,
-      status: 'Preparation',
-      dependedIssueUrls: ['https://github.com/user/repo/issues/99'],
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(project);
-
-    await useCase.run({
-      project,
-      issues: [issue],
-      agents: ['chore', 'accounting'],
-    });
-
-    expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledWith(
-      issue.url,
-      project,
-      'option-chore-id',
-    );
-    expect(mockIssueRepository.removeLabel).toHaveBeenCalledWith(
-      issue,
-      'chore',
-    );
-    expect(issue.agent).toBe('chore');
-    expect(issue.labels).not.toContain('chore');
-  });
-
-  it('should not modify an item with no label matching any configured agent name', async () => {
-    const project = createProject([{ id: 'option-chore-id', name: 'chore' }]);
-    const issue = createIssue({
-      labels: ['bug', 'feature'],
-      agent: null,
-    });
-
-    await useCase.run({
-      project,
-      issues: [issue],
-      agents: ['chore'],
-    });
-
-    expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
-    expect(mockIssueRepository.removeLabel).not.toHaveBeenCalled();
-    expect(issue.agent).toBeNull();
-    expect(issue.labels).toEqual(['bug', 'feature']);
-  });
-
-  it('should not modify an item whose Agent field is already set', async () => {
-    const project = createProject([{ id: 'option-chore-id', name: 'chore' }]);
-    const issue = createIssue({
-      labels: ['chore'],
-      agent: 'chore',
-    });
-
-    await useCase.run({
-      project,
-      issues: [issue],
-      agents: ['chore'],
-    });
-
-    expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
-    expect(mockIssueRepository.removeLabel).not.toHaveBeenCalled();
-  });
-
-  it('should skip closed items', async () => {
-    const project = createProject([{ id: 'option-chore-id', name: 'chore' }]);
-    const issue = createIssue({
-      labels: ['chore'],
-      agent: null,
-      isClosed: true,
-    });
-
-    await useCase.run({
-      project,
-      issues: [issue],
-      agents: ['chore'],
-    });
-
-    expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
-    expect(mockIssueRepository.removeLabel).not.toHaveBeenCalled();
-  });
-
-  it('should do nothing when agents is null', async () => {
-    const project = createProject([{ id: 'option-chore-id', name: 'chore' }]);
-    const issue = createIssue({
-      labels: ['chore'],
-      agent: null,
-    });
-
-    await useCase.run({
-      project,
-      issues: [issue],
-      agents: null,
-    });
-
-    expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
-    expect(mockIssueRepository.removeLabel).not.toHaveBeenCalled();
-  });
-
-  it('should process all items in the list and adopt each matching label', async () => {
-    const project = createProject([
-      { id: 'option-chore-id', name: 'chore' },
-      { id: 'option-accounting-id', name: 'accounting' },
-    ]);
-    const issueChore = createIssue({
-      url: 'https://github.com/user/repo/issues/1',
-      labels: ['chore'],
-      agent: null,
-      status: 'In Review',
-    });
-    const issueAccounting = createIssue({
-      url: 'https://github.com/user/repo/issues/2',
-      labels: ['accounting'],
-      agent: null,
-      status: 'Awaiting Workspace',
-    });
-    mockProjectRepository.getByUrl.mockResolvedValue(project);
-
-    await useCase.run({
-      project,
-      issues: [issueChore, issueAccounting],
-      agents: ['chore', 'accounting'],
-    });
-
-    expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledTimes(2);
-    expect(issueChore.agent).toBe('chore');
-    expect(issueAccounting.agent).toBe('accounting');
-  });
-});

package/src/domain/usecases/AgentDesignationLabelAdoptUseCase.ts

@@ -1,76 +0,0 @@
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
-import { ensureAgentOptionAndGetId } from './ensureAgentOptionAndGetId';
-import { Issue } from '../entities/Issue';
-import { Project } from '../entities/Project';
-
-export const adoptIssueAgentDesignationLabel = async (
-  issue: Issue,
-  project: Project,
-  configuredAgentNames: string[],
-  projectRepository: Pick<
-    ProjectRepository,
-    'getByUrl' | 'createField' | 'updateAgentList'
-  >,
-  issueRepository: Pick<IssueRepository, 'setIssueAgentField' | 'removeLabel'>,
-): Promise<void> => {
-  if (issue.agent !== null) {
-    return;
-  }
-  const agentLabel = issue.labels.find((label) =>
-    configuredAgentNames.includes(label),
-  );
-  if (agentLabel === undefined) {
-    return;
-  }
-  issue.agent = agentLabel;
-  const agentOptionId = await ensureAgentOptionAndGetId(
-    projectRepository,
-    project,
-    agentLabel,
-  );
-  if (agentOptionId === null) {
-    console.warn(
-      `Agent field option '${agentLabel}' could not be resolved for ${issue.url}. Keeping the label as the agent designation.`,
-    );
-    return;
-  }
-  await issueRepository.setIssueAgentField(issue.url, project, agentOptionId);
-  await issueRepository.removeLabel(issue, agentLabel);
-  issue.labels = issue.labels.filter((label) => label !== agentLabel);
-};
-
-export class AgentDesignationLabelAdoptUseCase {
-  constructor(
-    private readonly projectRepository: Pick<
-      ProjectRepository,
-      'getByUrl' | 'createField' | 'updateAgentList'
-    >,
-    private readonly issueRepository: Pick<
-      IssueRepository,
-      'setIssueAgentField' | 'removeLabel'
-    >,
-  ) {}
-
-  run = async (params: {
-    project: Project;
-    issues: Issue[];
-    agents: string[] | null;
-  }): Promise<void> => {
-    if (!params.agents || params.agents.length === 0) {
-      return;
-    }
-    for (const issue of params.issues) {
-      if (issue.isClosed) {
-        continue;
-      }
-      await adoptIssueAgentDesignationLabel(
-        issue,
-        params.project,
-        params.agents,
-        this.projectRepository,
-        this.issueRepository,
-      );
-    }
-  };
-}

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

@@ -1,118 +0,0 @@
-import { mock } from 'jest-mock-extended';
-import { AnalyzeProblemByIssueUseCase } from './AnalyzeProblemByIssueUseCase';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { DateRepository } from './adapter-interfaces/DateRepository';
-import { Issue } from '../entities/Issue';
-import { StoryObject, StoryObjectMap } from '../entities/StoryObjectMap';
-import { Project, StoryOption } from '../entities/Project';
-
-describe('AnalyzeProblemByIssueUseCase', () => {
-  const mockIssueRepository = mock<IssueRepository>();
-  const mockDateRepository = mock<DateRepository>();
-  const useCase = new AnalyzeProblemByIssueUseCase(
-    mockIssueRepository,
-    mockDateRepository,
-  );
-
-  describe('createSummaryCommentBody', () => {
-    const createIssueWithTitle = (title: string): Issue => {
-      const issue = mock<Issue>();
-      issue.url = 'https://github.com/org/repo/issues/1';
-      issue.number = 1;
-      issue.title = title;
-      issue.isClosed = false;
-      issue.assignees = [];
-      issue.dependedIssueUrls = [];
-      issue.estimationMinutes = null;
-      issue.completionDate50PercentConfidence = null;
-      return issue;
-    };
-
-    const createStoryIssue = (): Issue => {
-      const issue = mock<Issue>();
-      issue.url = 'https://github.com/org/repo/issues/100';
-      issue.number = 100;
-      issue.title = 'Story';
-      return issue;
-    };
-
-    it('should replace all double-quote characters in the issue title with single quotes', () => {
-      const titleWithMultipleQuotes = 'a"b"c"d';
-      const storyObject: StoryObject & { storyIssue: Issue } = {
-        story: mock<StoryOption>(),
-        storyIssue: createStoryIssue(),
-        issues: [createIssueWithTitle(titleWithMultipleQuotes)],
-      };
-
-      const result = useCase.createSummaryCommentBody(storyObject);
-
-      expect(result).toContain("a'b'c'd");
-      expect(result).not.toContain('a"b');
-    });
-
-    it('should leave titles without double-quote characters unchanged', () => {
-      const plainTitle = 'plain title';
-      const storyObject: StoryObject & { storyIssue: Issue } = {
-        story: mock<StoryOption>(),
-        storyIssue: createStoryIssue(),
-        issues: [createIssueWithTitle(plainTitle)],
-      };
-
-      const result = useCase.createSummaryCommentBody(storyObject);
-
-      expect(result).toContain(plainTitle);
-    });
-  });
-
-  describe('run', () => {
-    const midnight = new Date(2026, 7, 9, 0, 0, 0);
-
-    const createStoryObjectMap = (): StoryObjectMap => {
-      const storyIssue = mock<Issue>();
-      storyIssue.url = 'https://github.com/org/repo/issues/100';
-      storyIssue.number = 100;
-      storyIssue.title = 'Story';
-      const storyObject: StoryObject = {
-        story: mock<StoryOption>(),
-        storyIssue,
-        issues: [],
-      };
-      return new Map([['story', storyObject]]);
-    };
-
-    const createProject = (): Project => {
-      const project = mock<Project>();
-      project.story = mock<Project['story']>();
-      return project;
-    };
-
-    beforeEach(() => {
-      mockIssueRepository.createComment.mockReset();
-    });
-
-    it('does not comment on any story issue when the story progress comment is disabled', async () => {
-      await useCase.run({
-        targetDates: [midnight],
-        project: createProject(),
-        storyObjectMap: createStoryObjectMap(),
-        storyProgressCommentEnabled: false,
-      });
-
-      expect(mockIssueRepository.createComment).not.toHaveBeenCalled();
-    });
-
-    it('comments on the story issue when the story progress comment option is absent', async () => {
-      jest.useFakeTimers();
-      const running = useCase.run({
-        targetDates: [midnight],
-        project: createProject(),
-        storyObjectMap: createStoryObjectMap(),
-      });
-      await jest.advanceTimersByTimeAsync(5000);
-      await running;
-      jest.useRealTimers();
-
-      expect(mockIssueRepository.createComment).toHaveBeenCalledTimes(1);
-    });
-  });
-});

package/src/domain/usecases/AnalyzeProblemByIssueUseCase.ts

@@ -1,112 +0,0 @@
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { Project } from '../entities/Project';
-import { DateRepository } from './adapter-interfaces/DateRepository';
-import { StoryObject, StoryObjectMap } from '../entities/StoryObjectMap';
-
-export class AnalyzeProblemByIssueUseCase {
-  constructor(
-    readonly issueRepository: Pick<IssueRepository, 'createComment'>,
-    readonly dateRepository: Pick<
-      DateRepository,
-      'formatDurationToHHMM' | 'formatDateWithDayOfWeek'
-    >,
-  ) {}
-
-  run = async (input: {
-    targetDates: Date[];
-    project: Project;
-    storyObjectMap: StoryObjectMap;
-    storyProgressCommentEnabled?: boolean;
-  }): Promise<void> => {
-    const storyProgressCommentEnabled =
-      input.storyProgressCommentEnabled ?? true;
-    const story = input.project.story;
-    if (
-      !storyProgressCommentEnabled ||
-      !story ||
-      !input.targetDates.find(
-        (targetDate) =>
-          targetDate.getUTCHours() === 0 && targetDate.getUTCMinutes() === 0,
-      )
-    ) {
-      return;
-    }
-    const targetDate = input.targetDates[input.targetDates.length - 1];
-    if (!targetDate) {
-      return;
-    }
-    for (const storyObject of input.storyObjectMap.values()) {
-      const storyIssue = storyObject.storyIssue;
-      if (!storyIssue) {
-        continue;
-      }
-      await this.issueRepository.createComment(
-        storyIssue,
-        this.createSummaryCommentBody({ ...storyObject, storyIssue }),
-      );
-      await new Promise((resolve) => setTimeout(resolve, 5000));
-    }
-  };
-  createSummaryCommentBody = (
-    storyObject: StoryObject & {
-      storyIssue: NonNullable<StoryObject['storyIssue']>;
-    },
-  ): string => {
-    const getFlowchartIdFromUrl = (url: string) => {
-      return url.split('/').slice(-3).join('/');
-    };
-    const issueTitleForFlowchart = (title: string) => {
-      return title.replace(/"/g, "'");
-    };
-    const flowChart = `
-\`\`\`mermaid
-
-flowchart TD
-${storyObject.issues
-  .map(
-    (issue) =>
-      `    ${getFlowchartIdFromUrl(issue.url)}["${issue.isClosed ? '🟣' : '🟢'}#${issue.number} ${issue.isClosed ? 'Closed' : 'Open'}<br/>${issue.assignees.map((a) => `${a}`).join('<br/>')}<br/>${issueTitleForFlowchart(issue.title)}"]`,
-  )
-  .join('\n')}
-${storyObject.issues
-  .map((issue) =>
-    Array.from(issue.dependedIssueUrls)
-      .map((dependedIssueUrl) => {
-        if (issue.isClosed) {
-          return `    ${getFlowchartIdFromUrl(dependedIssueUrl)} --> ${getFlowchartIdFromUrl(issue.url)}`;
-        }
-        return `    ${getFlowchartIdFromUrl(dependedIssueUrl)} -->|${
-          issue.estimationMinutes
-            ? `Estimation: ${this.dateRepository.formatDurationToHHMM(issue.estimationMinutes)}<br/>`
-            : ''
-        }<br/>by ${
-          issue.completionDate50PercentConfidence
-            ? this.dateRepository.formatDateWithDayOfWeek(
-                issue.completionDate50PercentConfidence,
-              )
-            : 'Unknown'
-        }| ${getFlowchartIdFromUrl(issue.url)}`;
-      })
-      .join('\n'),
-  )
-  .join('\n')}
-    %% click event
-    ${storyObject.issues
-      .map(
-        (issue) => `click ${getFlowchartIdFromUrl(issue.url)} "${issue.url}"`,
-      )
-      .join('\n')}
-
-\`\`\``;
-    let noMultipleNewLineBody = `
-${storyObject.issues.map((issue) => `- ${issue.url}`).join('\n')}`;
-
-    while (noMultipleNewLineBody.includes('\n\n')) {
-      noMultipleNewLineBody = noMultipleNewLineBody.replace('\n\n', '\n');
-    }
-    return `${flowChart}
-
-${noMultipleNewLineBody}
-`;
-  };
-}

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

@@ -1,82 +0,0 @@
-import { mock } from 'jest-mock-extended';
-import { AnalyzeStoriesUseCase } from './AnalyzeStoriesUseCase';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { DateRepository } from './adapter-interfaces/DateRepository';
-import { Project } from '../entities/Project';
-import { StoryObject } from '../entities/StoryObjectMap';
-
-describe('AnalyzeStoriesUseCase', () => {
-  const mockIssueRepository = mock<IssueRepository>();
-  const mockDateRepository = mock<DateRepository>();
-
-  let useCase: AnalyzeStoriesUseCase;
-
-  const projectWithStory: Project = {
-    ...mock<Project>(),
-    story: {
-      name: 'Story',
-      fieldId: 'story-field',
-      databaseId: 1,
-      stories: [],
-      workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
-    },
-  };
-
-  const commonInput = {
-    project: projectWithStory,
-    issues: [],
-    cacheUsed: false,
-    manager: 'manager-user',
-    org: 'org',
-    repo: 'repo',
-    urlOfStoryView: 'https://github.com/org/repo',
-    storyObjectMap: new Map<string, StoryObject>(),
-    members: [],
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    useCase = new AnalyzeStoriesUseCase(
-      mockIssueRepository,
-      mockDateRepository,
-    );
-  });
-
-  describe('run — UTC 05:00 guard', () => {
-    it('returns early when no targetDate is at UTC 05:00', async () => {
-      const nonMatchingDate = new Date(Date.UTC(2026, 0, 15, 4, 0, 0));
-
-      await useCase.run({ ...commonInput, targetDates: [nonMatchingDate] });
-
-      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
-    });
-
-    it('proceeds when a targetDate is exactly UTC 05:00', async () => {
-      const matchingDate = new Date(Date.UTC(2026, 0, 15, 5, 0, 0));
-
-      await useCase.run({ ...commonInput, targetDates: [matchingDate] });
-
-      expect(mockIssueRepository.createNewIssue).toHaveBeenCalledTimes(1);
-      const body = mockIssueRepository.createNewIssue.mock.calls[0][3];
-      expect(body).toContain('From: :robot: AnalyzeStoriesUseCase');
-    });
-
-    it('returns early when project has no story field', async () => {
-      const projectWithoutStory: Project = { ...projectWithStory, story: null };
-
-      await useCase.run({
-        ...commonInput,
-        project: projectWithoutStory,
-        targetDates: [new Date(Date.UTC(2026, 0, 15, 5, 0, 0))],
-      });
-
-      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
-    });
-
-    it('returns early when targetDates is empty', async () => {
-      await useCase.run({ ...commonInput, targetDates: [] });
-
-      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
-    });
-  });
-});