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

package/src/domain/usecases/ConflictedIssueRevertUseCase.ts

@@ -1,146 +0,0 @@
-import { Issue } from '../entities/Issue';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { ProjectRepository } from './adapter-interfaces/ProjectRepository';
-import { IssueCommentRepository } from './adapter-interfaces/IssueCommentRepository';
-import {
-  AWAITING_WORKSPACE_STATUS_NAME,
-  DONE_STATUS_NAME,
-  FAILED_PREPARATION_STATUS_NAME,
-  ICEBOX_STATUS_NAME,
-  IN_TMUX_STATUS_NAME,
-} from '../entities/WorkflowStatus';
-
-const EXCLUDED_STATUSES = new Set([
-  DONE_STATUS_NAME,
-  ICEBOX_STATUS_NAME,
-  FAILED_PREPARATION_STATUS_NAME,
-  IN_TMUX_STATUS_NAME,
-]);
-
-export class ConflictedIssueRevertUseCase {
-  constructor(
-    private readonly projectRepository: Pick<
-      ProjectRepository,
-      'findProjectIdByUrl' | 'getProject'
-    >,
-    private readonly issueRepository: Pick<
-      IssueRepository,
-      'getAllIssues' | 'getOpenPullRequests' | 'updateStatus' | 'updateBranch'
-    >,
-    private readonly issueCommentRepository: Pick<
-      IssueCommentRepository,
-      'createComment'
-    >,
-  ) {}
-
-  run = async (params: { projectUrl: string }): Promise<void> => {
-    const projectId = await this.projectRepository.findProjectIdByUrl(
-      params.projectUrl,
-    );
-    if (!projectId) {
-      throw new Error(`Project not found. projectUrl: ${params.projectUrl}`);
-    }
-    const project = await this.projectRepository.getProject(projectId);
-    if (!project) {
-      throw new Error(
-        `Project not found. projectId: ${projectId} projectUrl: ${params.projectUrl}`,
-      );
-    }
-
-    const awaitingWorkspaceStatusOption = project.status.statuses.find(
-      (s) => s.name === AWAITING_WORKSPACE_STATUS_NAME,
-    );
-    if (!awaitingWorkspaceStatusOption) {
-      return;
-    }
-
-    const { issues } = await this.issueRepository.getAllIssues(projectId);
-
-    const targetIssues = issues.filter(
-      (issue) =>
-        !issue.isPr &&
-        (issue.status === null || !EXCLUDED_STATUSES.has(issue.status)),
-    );
-
-    const relatedOpenPrUrlsByIssueUrl =
-      this.buildRelatedOpenPrUrlsByIssueUrl(issues);
-
-    const allPrUrls = Array.from(
-      new Set(
-        targetIssues.flatMap(
-          (issue) => relatedOpenPrUrlsByIssueUrl.get(issue.url) ?? [],
-        ),
-      ),
-    );
-
-    if (allPrUrls.length === 0) {
-      return;
-    }
-
-    const resolvedPrByUrl =
-      await this.issueRepository.getOpenPullRequests(allPrUrls);
-
-    for (const issue of targetIssues) {
-      const prUrls = relatedOpenPrUrlsByIssueUrl.get(issue.url) ?? [];
-      if (prUrls.length === 0) {
-        continue;
-      }
-
-      const relatedPrs = prUrls
-        .map((url) => resolvedPrByUrl.get(url) ?? null)
-        .filter((pr): pr is NonNullable<typeof pr> => pr !== null);
-
-      const hasUnknownMergeable = relatedPrs.some(
-        (pr) => pr.mergeable === 'UNKNOWN',
-      );
-      if (hasUnknownMergeable) {
-        continue;
-      }
-
-      const conflictedPrs = relatedPrs.filter((pr) => pr.isConflicted);
-      if (conflictedPrs.length === 0) {
-        continue;
-      }
-
-      const allBranchesUpdated = (
-        await Promise.all(
-          conflictedPrs.map((pr) => this.issueRepository.updateBranch(pr.url)),
-        )
-      ).every(Boolean);
-      if (allBranchesUpdated) {
-        continue;
-      }
-
-      await this.issueRepository.updateStatus(
-        project,
-        issue,
-        awaitingWorkspaceStatusOption.id,
-      );
-      await this.issueCommentRepository.createComment(issue, 'conflict');
-    }
-  };
-
-  private buildRelatedOpenPrUrlsByIssueUrl = (
-    issues: Issue[],
-  ): Map<string, string[]> => {
-    const openPrUrlsByIssueUrl = new Map<string, Set<string>>();
-    for (const issue of issues) {
-      if (!issue.isPr || issue.isClosed) {
-        continue;
-      }
-      for (const referencedIssueUrl of issue.closingIssueReferenceUrls) {
-        const existing = openPrUrlsByIssueUrl.get(referencedIssueUrl);
-        if (existing) {
-          existing.add(issue.url);
-        } else {
-          openPrUrlsByIssueUrl.set(referencedIssueUrl, new Set([issue.url]));
-        }
-      }
-    }
-    const result = new Map<string, string[]>();
-    for (const [issueUrl, prUrls] of openPrUrlsByIssueUrl) {
-      result.set(issueUrl, Array.from(prUrls));
-    }
-    return result;
-  };
-}

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

@@ -1,227 +0,0 @@
-import { mock } from 'jest-mock-extended';
-import { CreateEstimationIssueUseCase } from './CreateEstimationIssueUseCase';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { DateRepository } from './adapter-interfaces/DateRepository';
-import { Project } from '../entities/Project';
-import { StoryObject } from '../entities/StoryObjectMap';
-import { Issue } from '../entities/Issue';
-
-describe('CreateEstimationIssueUseCase', () => {
-  const mockIssueRepository = mock<IssueRepository>();
-  const mockDateRepository = mock<DateRepository>();
-
-  let useCase: CreateEstimationIssueUseCase;
-
-  const projectWithStory: Project = {
-    ...mock<Project>(),
-    story: {
-      name: 'Story',
-      fieldId: 'story-field',
-      databaseId: 1,
-      stories: [],
-      workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
-    },
-    remainingEstimationMinutes: null,
-    completionDate50PercentConfidence: null,
-  };
-
-  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>(),
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    useCase = new CreateEstimationIssueUseCase(
-      mockIssueRepository,
-      mockDateRepository,
-    );
-  });
-
-  describe('run — UTC 07:00 guard', () => {
-    it('returns early when no targetDate is at UTC 07:00', async () => {
-      const nonMatchingDate = new Date(Date.UTC(2026, 0, 15, 6, 0, 0));
-
-      await useCase.run({ ...commonInput, targetDates: [nonMatchingDate] });
-
-      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
-    });
-
-    it('returns early when targetDates is empty', async () => {
-      await useCase.run({ ...commonInput, targetDates: [] });
-
-      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
-    });
-
-    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, 7, 0, 0))],
-      });
-
-      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('run — weekend skip', () => {
-    const projectWithNonRegularStory: Project = {
-      ...projectWithStory,
-      story: {
-        name: 'Story',
-        fieldId: 'story-field',
-        databaseId: 1,
-        stories: [
-          {
-            id: 'story-1',
-            name: 'Feature Story',
-            color: 'BLUE',
-            description: '',
-          },
-        ],
-        workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
-      },
-    };
-
-    it('returns early when the last targetDate falls on Saturday UTC', async () => {
-      const saturdayAt07h = new Date(Date.UTC(2026, 0, 17, 7, 0, 0));
-      expect(saturdayAt07h.getUTCDay()).toBe(6);
-
-      await useCase.run({
-        ...commonInput,
-        project: projectWithNonRegularStory,
-        targetDates: [saturdayAt07h],
-      });
-
-      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
-    });
-
-    it('returns early when the last targetDate falls on Sunday UTC', async () => {
-      const sundayAt07h = new Date(Date.UTC(2026, 0, 18, 7, 0, 0));
-      expect(sundayAt07h.getUTCDay()).toBe(0);
-
-      await useCase.run({
-        ...commonInput,
-        project: projectWithNonRegularStory,
-        targetDates: [sundayAt07h],
-      });
-
-      expect(mockIssueRepository.createNewIssue).not.toHaveBeenCalled();
-    });
-
-    it('proceeds past the weekend guard on a weekday UTC 07:00', async () => {
-      const thursdayAt07h = new Date(Date.UTC(2026, 0, 15, 7, 0, 0));
-      expect(thursdayAt07h.getUTCDay()).toBe(4);
-
-      await expect(
-        useCase.run({
-          ...commonInput,
-          project: projectWithNonRegularStory,
-          targetDates: [thursdayAt07h],
-        }),
-      ).rejects.toThrow('Story issue not found: Feature Story');
-    });
-  });
-
-  describe('run — completionDate50PercentConfidence Monday UTC reset', () => {
-    const mondayAt07hUTC = new Date(Date.UTC(2026, 0, 12, 7, 0, 0));
-
-    const featureStory = {
-      id: 'story-feat',
-      name: 'Feature Story',
-      color: 'BLUE' as const,
-      description: '',
-    };
-
-    const projectWithCompletionField: Project = {
-      ...mock<Project>(),
-      story: {
-        name: 'Story',
-        fieldId: 'story-field',
-        databaseId: 1,
-        stories: [featureStory],
-        workflowManagementStory: { id: 'wms-id', name: 'workflow management' },
-      },
-      remainingEstimationMinutes: null,
-      completionDate50PercentConfidence: {
-        name: 'Completion Date',
-        fieldId: 'completion-field',
-      },
-    };
-
-    const storyIssue: Issue = {
-      ...mock<Issue>(),
-      title: 'Feature Story',
-      labels: ['story', 'story:action:schedule-control'],
-      isClosed: false,
-      isPr: false,
-      url: 'https://github.com/org/repo/issues/1',
-    };
-
-    const farFutureDate = new Date(Date.UTC(2026, 5, 1, 0, 0, 0));
-    const issueInStory: Issue = {
-      ...mock<Issue>(),
-      title: 'Task issue',
-      labels: [],
-      isClosed: false,
-      isPr: false,
-      status: null,
-      estimationMinutes: null,
-      completionDate50PercentConfidence: farFutureDate,
-      assignees: ['dev-user'],
-    };
-
-    beforeEach(() => {
-      jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-      jest.useRealTimers();
-    });
-
-    it('clears completionDate50PercentConfidence on UTC Monday even when date is far in future', async () => {
-      expect(mondayAt07hUTC.getUTCDay()).toBe(1);
-
-      mockDateRepository.formatDateWithDayOfWeek.mockReturnValue(
-        'Mon, Jun 01, 2026',
-      );
-
-      const storyObjectMap = new Map<string, StoryObject>([
-        [
-          featureStory.name,
-          { story: featureStory, storyIssue, issues: [issueInStory] },
-        ],
-      ]);
-
-      const runPromise = useCase.run({
-        project: projectWithCompletionField,
-        issues: [storyIssue],
-        cacheUsed: false,
-        manager: 'manager-user',
-        org: 'org',
-        repo: 'repo',
-        urlOfStoryView: 'https://github.com/org/repo',
-        storyObjectMap,
-        targetDates: [mondayAt07hUTC],
-      });
-      await jest.runAllTimersAsync();
-      await runPromise;
-
-      expect(mockIssueRepository.clearProjectField).toHaveBeenCalledWith(
-        projectWithCompletionField,
-        'completion-field',
-        issueInStory,
-      );
-      const body = mockIssueRepository.createNewIssue.mock.calls[0]?.[3];
-      expect(body).toContain('From: :robot: CreateEstimationIssueUseCase');
-    });
-  });
-});

package/src/domain/usecases/CreateEstimationIssueUseCase.ts

@@ -1,205 +0,0 @@
-import { Issue } from '../entities/Issue';
-import { IssueRepository } from './adapter-interfaces/IssueRepository';
-import { Project } from '../entities/Project';
-import { Member } from '../entities/Member';
-import { DateRepository } from './adapter-interfaces/DateRepository';
-import { StoryObjectMap } from '../entities/StoryObjectMap';
-import { encodeForURI } from './utils';
-import { ICEBOX_STATUS_NAME } from '../entities/WorkflowStatus';
-
-export class CreateEstimationIssueUseCase {
-  constructor(
-    readonly issueRepository: Pick<
-      IssueRepository,
-      'createNewIssue' | 'clearProjectField' | 'createComment'
-    >,
-    readonly dateRepository: Pick<DateRepository, 'formatDateWithDayOfWeek'>,
-  ) {}
-
-  run = async (input: {
-    targetDates: Date[];
-    project: Project;
-    issues: Issue[];
-    cacheUsed: boolean;
-    manager: Member['name'];
-    org: string;
-    repo: string;
-    urlOfStoryView: string;
-    storyObjectMap: StoryObjectMap;
-  }): Promise<void> => {
-    const story = input.project.story;
-    if (
-      !story ||
-      !input.targetDates.find(
-        (targetDate) =>
-          targetDate.getUTCHours() === 7 && targetDate.getUTCMinutes() === 0,
-      )
-    ) {
-      return;
-    }
-    const targetDate = input.targetDates[input.targetDates.length - 1];
-    if (!targetDate) {
-      return;
-    }
-    if (targetDate.getUTCDay() === 0 || targetDate.getUTCDay() === 6) {
-      return;
-    }
-
-    for (const story of input.project.story?.stories || []) {
-      const storyIssue = input.issues.find((issue) =>
-        story.name.startsWith(issue.title),
-      );
-      const storyObject = input.storyObjectMap.get(story.name);
-      if (story.name.startsWith('regular / ')) {
-        continue;
-      } else if (!storyIssue || !storyObject) {
-        throw new Error(`Story issue not found: ${story.name}`);
-      } else if (!storyIssue.labels.includes('story:action:schedule-control')) {
-        continue;
-      }
-      const estimationMinutesField = input.project.remainingEstimationMinutes;
-      const completionDate50PercentConfidenceField =
-        input.project.completionDate50PercentConfidence;
-      const assignees: Set<Member['name']> = new Set();
-      for (const issueInStory of storyObject.issues) {
-        if (
-          issueInStory.isClosed ||
-          issueInStory.isPr ||
-          issueInStory.labels.includes('story') ||
-          issueInStory.status === ICEBOX_STATUS_NAME
-        ) {
-          continue;
-        }
-        if (
-          estimationMinutesField &&
-          !!issueInStory.estimationMinutes &&
-          issueInStory.estimationMinutes > 0
-        ) {
-          await this.issueRepository.createComment(
-            issueInStory,
-            `\`${estimationMinutesField.name}\` field value \`${issueInStory.estimationMinutes}\` is removed to re-estimate.`,
-          );
-          await this.issueRepository.clearProjectField(
-            input.project,
-            estimationMinutesField.fieldId,
-            issueInStory,
-          );
-          await new Promise((resolve) => setTimeout(resolve, 5000));
-        }
-        if (
-          completionDate50PercentConfidenceField &&
-          !!issueInStory.completionDate50PercentConfidence &&
-          (issueInStory.completionDate50PercentConfidence.getTime() <
-            targetDate.getTime() + 7 * 24 * 60 * 60 * 1000 ||
-            targetDate.getUTCDay() === 1)
-        ) {
-          await this.issueRepository.createComment(
-            issueInStory,
-            `\`${completionDate50PercentConfidenceField.name}\` field value \`${this.dateRepository.formatDateWithDayOfWeek(issueInStory.completionDate50PercentConfidence)}\` is removed to re-estimate.`,
-          );
-          await this.issueRepository.clearProjectField(
-            input.project,
-            completionDate50PercentConfidenceField.fieldId,
-            issueInStory,
-          );
-          await new Promise((resolve) => setTimeout(resolve, 5000));
-        }
-        for (const assignee of issueInStory.assignees) {
-          assignees.add(assignee);
-        }
-      }
-      for (const assignee of assignees) {
-        await this.issueRepository.createNewIssue(
-          input.org,
-          input.repo,
-          `Put estimation fields of \`${story.name}\` for ${assignee} :pray:`,
-          this.createEstimationIssueBody(
-            { storyIssue, issues: storyObject.issues },
-            input.urlOfStoryView,
-            input.project,
-          ),
-          [assignee],
-          ['story:workflow-management'],
-        );
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-      }
-    }
-  };
-  createEstimationIssueBody = (
-    storyObject: {
-      storyIssue: Issue;
-      issues: Issue[];
-    },
-    urlObStoryView: string,
-    project: Project,
-  ): string => {
-    return `From: :robot: CreateEstimationIssueUseCase
-
-This issue is experimental workflow :pray:
-- Target story: ${storyObject.storyIssue.url}
-
-## Tasks
-- [ ] 1. Fill \`50% confidence completion date\` to all issues on ${urlObStoryView}?filterQuery=story%3A%22${encodeForURI(storyObject.storyIssue.story)}%22+is%3Aopen+no%3A%22${encodeForURI(project.completionDate50PercentConfidence?.name)}%22+assignee%3A%40me+-label%3Astory
-- [ ] 2. Fill \`Remaining Estimation (minutes)\` to all issues on ${urlObStoryView}?filterQuery=story%3A%22${encodeForURI(storyObject.storyIssue.story)}%22+is%3Aopen+no%3A%22${encodeForURI(project.remainingEstimationMinutes?.name)}%22+assignee%3A%40me+-label%3Astory
-- [ ] 3. Take screenshot and comment to this issue about ${urlObStoryView}?filterQuery=story%3A%22${encodeForURI(storyObject.storyIssue.story)}%22+is%3Aopen+assignee%3A%40me+-label%3Astory
-- [ ] 4. Close
-
-⚡⚡⚡
-Dont forget, it's just 50% confidence :pray:
-This is the date you think you have a 50-50 chance of completing the task. Think of it as "if everything goes normally (not best-case, not worst-case), when would this be done?"
-
-Important: You will NOT be held accountable if you miss this date. We're using this for project planning, not for performance evaluation. We manage delays and risks at the project level with buffers.
-
-Please give your honest estimate without adding any "just in case" padding. Focus only on the actual work time needed, assuming things go smoothly but not perfectly.
-
-That's all! Let me know if you have any questions.
-⚡⚡⚡
-`;
-  };
-  createSummaryIssueBody = (
-    summaryStoryIssue: Map<
-      string,
-      (Issue & {
-        name: string;
-        color: string;
-        description: string;
-      })[]
-    >,
-    urlOfStoryView: string,
-  ): string => {
-    return `
-
-${Array.from(summaryStoryIssue.keys())
-  .map((key) => {
-    return `
-## ${key}
-${summaryStoryIssue
-  .get(key)
-  ?.map((issue) => {
-    const storyColor = `:${issue.color === 'BLUE' ? 'large_' : ''}${issue.color === 'GRAY' ? 'black' : issue.color === 'PINK' ? 'red' : issue.color.toLowerCase()}_circle:`;
-    const stakeHolder = issue.labels.find(
-      (label) => label === 'story:stakeholder:user',
-    )
-      ? `:bust_in_silhouette:`
-      : issue.labels.find((label) => label === 'story:stakeholder:engineer')
-        ? `:gear:`
-        : issue.labels.find((label) => label === 'story:stakeholder:cs-team')
-          ? `:headphones:`
-          : issue.labels.find(
-                (label) => label === 'story:stakeholder:potential-user',
-              )
-            ? ':busts_in_silhouette:'
-            : issue.labels.find(
-                  (label) => label === 'story:stakeholder:sales-team',
-                )
-              ? ':briefcase:'
-              : ':question:';
-    const boardUrl = `${urlOfStoryView}?filterQuery=story%3A%22${encodeForURI(issue.story)}%22+is%3Aopen`;
-
-    return `- ${storyColor} ${stakeHolder} ${issue.url} [:memo:](${boardUrl})`;
-  })
-  .join('\n')}`;
-  })
-  .join('\n')}`;
-  };
-}