github-issue-tower-defence-management 1.88.0 → 1.89.0

package/src/adapter/entry-points/console/consoleOperationApi.ts

@@ -0,0 +1,280 @@
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import { Project } from '../../../domain/entities/Project';
+import { Issue } from '../../../domain/entities/Issue';
+import { recordDoneProjectItemIdAcrossTabs } from './consoleDoneStore';
+
+export const AWAITING_WORKSPACE_STATUS_NAME = 'awaiting workspace';
+export const IN_TMUX_BY_HUMAN_STATUS_NAME = 'in tmux by human';
+
+export type ConsoleOperationContext = {
+  issueRepository: IssueRepository;
+  project: Project;
+  consoleDataOutputDir: string | null;
+  pjcode: string | null;
+};
+
+export type ConsoleOperationResponse = {
+  statusCode: number;
+  body: unknown;
+};
+
+const ok = (): ConsoleOperationResponse => ({
+  statusCode: 200,
+  body: { ok: true },
+});
+
+const badRequest = (message: string): ConsoleOperationResponse => ({
+  statusCode: 400,
+  body: { error: message },
+});
+
+const isNonEmptyString = (value: unknown): value is string =>
+  typeof value === 'string' && value.length > 0;
+
+const resolveStatusId = (
+  project: Project,
+  statusName: string,
+): string | null => {
+  const lower = statusName.toLowerCase();
+  const match = project.status.statuses.find(
+    (option) => option.name.toLowerCase() === lower,
+  );
+  return match ? match.id : null;
+};
+
+const loadIssueWithProjectItemId = async (
+  context: ConsoleOperationContext,
+  issueUrl: string,
+  projectItemId: string,
+): Promise<Issue | null> => {
+  const issue = await context.issueRepository.get(issueUrl, context.project);
+  if (issue === null) {
+    return null;
+  }
+  return { ...issue, itemId: projectItemId };
+};
+
+const recordDone = (
+  context: ConsoleOperationContext,
+  projectItemId: string,
+): void => {
+  if (context.consoleDataOutputDir === null || context.pjcode === null) {
+    return;
+  }
+  recordDoneProjectItemIdAcrossTabs(
+    context.consoleDataOutputDir,
+    context.pjcode,
+    projectItemId,
+  );
+};
+
+const updateStatusByName = async (
+  context: ConsoleOperationContext,
+  issueUrl: string,
+  projectItemId: string,
+  statusName: string,
+): Promise<ConsoleOperationResponse | null> => {
+  const statusId = resolveStatusId(context.project, statusName);
+  if (statusId === null) {
+    return badRequest(`status option "${statusName}" not found in project`);
+  }
+  const issue = await loadIssueWithProjectItemId(
+    context,
+    issueUrl,
+    projectItemId,
+  );
+  if (issue === null) {
+    return badRequest('issue not found');
+  }
+  await context.issueRepository.updateStatus(context.project, issue, statusId);
+  return null;
+};
+
+export const handleReview = async (
+  context: ConsoleOperationContext,
+  body: Record<string, unknown>,
+): Promise<ConsoleOperationResponse> => {
+  const action = body.action;
+  const prUrl = body.prUrl;
+  const projectItemId = body.projectItemId;
+  if (!isNonEmptyString(action)) {
+    return badRequest('action is required');
+  }
+  if (!isNonEmptyString(prUrl)) {
+    return badRequest('prUrl is required');
+  }
+  if (!isNonEmptyString(projectItemId)) {
+    return badRequest('projectItemId is required');
+  }
+
+  if (action === 'approve') {
+    await context.issueRepository.approvePullRequest(prUrl);
+    const failure = await updateStatusByName(
+      context,
+      prUrl,
+      projectItemId,
+      AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (failure !== null) {
+      return failure;
+    }
+    recordDone(context, projectItemId);
+    return ok();
+  }
+
+  if (action === 'request_changes') {
+    const commentBody = body.commentBody;
+    if (!isNonEmptyString(commentBody)) {
+      return badRequest('commentBody is required for request_changes');
+    }
+    const changedFilePath = isNonEmptyString(body.changedFilePath)
+      ? body.changedFilePath
+      : null;
+    await context.issueRepository.requestChangesWithInlineComment(
+      prUrl,
+      changedFilePath,
+      commentBody,
+    );
+    const failure = await updateStatusByName(
+      context,
+      prUrl,
+      projectItemId,
+      AWAITING_WORKSPACE_STATUS_NAME,
+    );
+    if (failure !== null) {
+      return failure;
+    }
+    recordDone(context, projectItemId);
+    return ok();
+  }
+
+  if (action === 'close') {
+    await context.issueRepository.closePullRequest(prUrl);
+    if (isNonEmptyString(body.commentBody)) {
+      await context.issueRepository.createCommentByUrl(prUrl, body.commentBody);
+    }
+    recordDone(context, projectItemId);
+    return ok();
+  }
+
+  return badRequest(`unknown review action "${action}"`);
+};
+
+export const handleTriage = async (
+  context: ConsoleOperationContext,
+  body: Record<string, unknown>,
+): Promise<ConsoleOperationResponse> => {
+  const action = body.action;
+  const issueUrl = body.issueUrl;
+  const projectItemId = body.projectItemId;
+  if (!isNonEmptyString(action)) {
+    return badRequest('action is required');
+  }
+  if (!isNonEmptyString(issueUrl)) {
+    return badRequest('issueUrl is required');
+  }
+  if (!isNonEmptyString(projectItemId)) {
+    return badRequest('projectItemId is required');
+  }
+
+  if (action === 'set_status') {
+    const statusName = body.statusName;
+    if (!isNonEmptyString(statusName)) {
+      return badRequest('statusName is required for set_status');
+    }
+    const failure = await updateStatusByName(
+      context,
+      issueUrl,
+      projectItemId,
+      statusName,
+    );
+    if (failure !== null) {
+      return failure;
+    }
+    recordDone(context, projectItemId);
+    return ok();
+  }
+
+  if (action === 'set_story') {
+    const storyOptionId = body.storyOptionId;
+    if (!isNonEmptyString(storyOptionId)) {
+      return badRequest('storyOptionId is required for set_story');
+    }
+    if (context.project.story === null) {
+      return badRequest('project does not have a story field');
+    }
+    const issue = await loadIssueWithProjectItemId(
+      context,
+      issueUrl,
+      projectItemId,
+    );
+    if (issue === null) {
+      return badRequest('issue not found');
+    }
+    await context.issueRepository.updateStory(
+      { ...context.project, story: context.project.story },
+      issue,
+      storyOptionId,
+    );
+    recordDone(context, projectItemId);
+    return ok();
+  }
+
+  if (action === 'close') {
+    await context.issueRepository.closePullRequest(issueUrl);
+    if (isNonEmptyString(body.commentBody)) {
+      await context.issueRepository.createCommentByUrl(
+        issueUrl,
+        body.commentBody,
+      );
+    }
+    recordDone(context, projectItemId);
+    return ok();
+  }
+
+  if (action === 'snooze_1day' || action === 'snooze_1week') {
+    const days = action === 'snooze_1day' ? 1 : 7;
+    const target = new Date(Date.now() + days * 24 * 60 * 60 * 1000);
+    await context.issueRepository.updateNextActionDate(
+      issueUrl,
+      context.project,
+      target,
+    );
+    recordDone(context, projectItemId);
+    return ok();
+  }
+
+  return badRequest(`unknown triage action "${action}"`);
+};
+
+export const handleIntmux = async (
+  context: ConsoleOperationContext,
+  body: Record<string, unknown>,
+): Promise<ConsoleOperationResponse> => {
+  const action = body.action;
+  const issueUrl = body.issueUrl;
+  const projectItemId = body.projectItemId;
+  if (!isNonEmptyString(action)) {
+    return badRequest('action is required');
+  }
+  if (action !== 'set_intmux') {
+    return badRequest(`unknown intmux action "${action}"`);
+  }
+  if (!isNonEmptyString(issueUrl)) {
+    return badRequest('issueUrl is required');
+  }
+  if (!isNonEmptyString(projectItemId)) {
+    return badRequest('projectItemId is required');
+  }
+  const failure = await updateStatusByName(
+    context,
+    issueUrl,
+    projectItemId,
+    IN_TMUX_BY_HUMAN_STATUS_NAME,
+  );
+  if (failure !== null) {
+    return failure;
+  }
+  recordDone(context, projectItemId);
+  return ok();
+};

package/src/adapter/entry-points/console/consoleReadApi.test.ts

@@ -0,0 +1,297 @@
+import { mock } from 'jest-mock-extended';
+import { IssueRepository } from '../../../domain/usecases/adapter-interfaces/IssueRepository';
+import {
+  ISSUE_TITLE_CACHE_TTL_MS,
+  IssueTitleStateCache,
+  handleComments,
+  handleIssueTitle,
+  handleItemBody,
+  handlePrCommits,
+  handlePrFiles,
+  handleRelatedPrs,
+} from './consoleReadApi';
+
+describe('consoleReadApi', () => {
+  describe('handleItemBody', () => {
+    it('returns 400 when url is missing', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const response = await handleItemBody(issueRepository, null);
+      expect(response.statusCode).toBe(400);
+    });
+
+    it('returns the body from the repository', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestBody.mockResolvedValue('body text');
+      const response = await handleItemBody(
+        issueRepository,
+        'https://github.com/o/r/issues/1',
+      );
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({ body: 'body text' });
+      expect(issueRepository.getIssueOrPullRequestBody).toHaveBeenCalledWith(
+        'https://github.com/o/r/issues/1',
+      );
+    });
+  });
+
+  describe('handleComments', () => {
+    it('serializes comment createdAt to ISO string', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestComments.mockResolvedValue([
+        {
+          author: 'octocat',
+          body: 'hello',
+          createdAt: new Date('2026-01-02T03:04:05Z'),
+        },
+      ]);
+      const response = await handleComments(
+        issueRepository,
+        'https://github.com/o/r/issues/1',
+      );
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({
+        comments: [
+          {
+            author: 'octocat',
+            body: 'hello',
+            createdAt: '2026-01-02T03:04:05.000Z',
+          },
+        ],
+      });
+    });
+
+    it('returns 400 when url is missing', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const response = await handleComments(issueRepository, null);
+      expect(response.statusCode).toBe(400);
+    });
+  });
+
+  describe('handlePrFiles', () => {
+    it('returns the files of the pull request detail', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getPullRequestDetail.mockResolvedValue({
+        title: 't',
+        state: 'OPEN',
+        merged: false,
+        isDraft: false,
+        additions: 1,
+        deletions: 0,
+        changedFiles: 1,
+        headRefName: 'feature',
+        baseRefName: 'main',
+        author: 'octocat',
+        files: [
+          {
+            filename: 'a.ts',
+            status: 'modified',
+            additions: 1,
+            deletions: 0,
+            patch: '@@ -1 +1 @@',
+          },
+        ],
+      });
+      const response = await handlePrFiles(
+        issueRepository,
+        'https://github.com/o/r/pull/1',
+      );
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({
+        files: [
+          {
+            filename: 'a.ts',
+            status: 'modified',
+            additions: 1,
+            deletions: 0,
+            patch: '@@ -1 +1 @@',
+          },
+        ],
+      });
+    });
+
+    it('returns null files when detail is null', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getPullRequestDetail.mockResolvedValue(null);
+      const response = await handlePrFiles(
+        issueRepository,
+        'https://github.com/o/r/pull/1',
+      );
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({ files: null });
+    });
+
+    it('returns 400 when url is missing', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const response = await handlePrFiles(issueRepository, null);
+      expect(response.statusCode).toBe(400);
+    });
+  });
+
+  describe('handlePrCommits', () => {
+    it('serializes commit authoredAt to ISO string', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getPullRequestCommits.mockResolvedValue([
+        {
+          sha: 'abc',
+          message: 'msg',
+          author: 'octocat',
+          authoredAt: new Date('2026-01-02T03:04:05Z'),
+        },
+      ]);
+      const response = await handlePrCommits(
+        issueRepository,
+        'https://github.com/o/r/pull/1',
+      );
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({
+        commits: [
+          {
+            sha: 'abc',
+            message: 'msg',
+            author: 'octocat',
+            authoredAt: '2026-01-02T03:04:05.000Z',
+          },
+        ],
+      });
+    });
+
+    it('returns 400 when url is missing', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const response = await handlePrCommits(issueRepository, null);
+      expect(response.statusCode).toBe(400);
+    });
+  });
+
+  describe('handleRelatedPrs', () => {
+    it('combines related pull requests with their summaries', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/o/r/pull/2',
+          branchName: 'feature',
+          createdAt: new Date('2026-01-02T03:04:05Z'),
+          isDraft: false,
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+      issueRepository.getPullRequestSummary.mockResolvedValue({
+        title: 'summary title',
+        body: 'summary body',
+        additions: 3,
+        deletions: 1,
+        changedFiles: 2,
+      });
+      const response = await handleRelatedPrs(
+        issueRepository,
+        'https://github.com/o/r/issues/1',
+      );
+      expect(response.statusCode).toBe(200);
+      expect(response.body).toEqual({
+        relatedPullRequests: [
+          {
+            url: 'https://github.com/o/r/pull/2',
+            branchName: 'feature',
+            createdAt: '2026-01-02T03:04:05.000Z',
+            isDraft: false,
+            isConflicted: false,
+            isPassedAllCiJob: true,
+            isCiStateSuccess: true,
+            isResolvedAllReviewComments: true,
+            isBranchOutOfDate: false,
+            missingRequiredCheckNames: [],
+            summary: {
+              title: 'summary title',
+              body: 'summary body',
+              additions: 3,
+              deletions: 1,
+              changedFiles: 2,
+            },
+          },
+        ],
+      });
+    });
+
+    it('returns 400 when url is missing', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const response = await handleRelatedPrs(issueRepository, null);
+      expect(response.statusCode).toBe(400);
+    });
+  });
+
+  describe('handleIssueTitle with the TTL cache', () => {
+    it('returns 400 when url is missing', async () => {
+      const issueRepository = mock<IssueRepository>();
+      const cache = new IssueTitleStateCache();
+      const response = await handleIssueTitle(issueRepository, cache, null);
+      expect(response.statusCode).toBe(400);
+    });
+
+    it('fetches on a cache miss and caches the result', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestState.mockResolvedValue({
+        state: 'OPEN',
+        merged: false,
+        isPullRequest: false,
+      });
+      const cache = new IssueTitleStateCache(() => 0);
+      const url = 'https://github.com/o/r/issues/1';
+      const first = await handleIssueTitle(issueRepository, cache, url);
+      expect(first.body).toEqual({
+        state: 'OPEN',
+        merged: false,
+        isPullRequest: false,
+      });
+      const second = await handleIssueTitle(issueRepository, cache, url);
+      expect(second.body).toEqual(first.body);
+      expect(issueRepository.getIssueOrPullRequestState).toHaveBeenCalledTimes(
+        1,
+      );
+    });
+
+    it('re-fetches a non-merged result after the TTL elapses', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestState.mockResolvedValue({
+        state: 'OPEN',
+        merged: false,
+        isPullRequest: true,
+      });
+      let now = 0;
+      const cache = new IssueTitleStateCache(() => now);
+      const url = 'https://github.com/o/r/pull/1';
+      await handleIssueTitle(issueRepository, cache, url);
+      now = ISSUE_TITLE_CACHE_TTL_MS - 1;
+      await handleIssueTitle(issueRepository, cache, url);
+      expect(issueRepository.getIssueOrPullRequestState).toHaveBeenCalledTimes(
+        1,
+      );
+      now = ISSUE_TITLE_CACHE_TTL_MS;
+      await handleIssueTitle(issueRepository, cache, url);
+      expect(issueRepository.getIssueOrPullRequestState).toHaveBeenCalledTimes(
+        2,
+      );
+    });
+
+    it('caches a merged result permanently', async () => {
+      const issueRepository = mock<IssueRepository>();
+      issueRepository.getIssueOrPullRequestState.mockResolvedValue({
+        state: 'CLOSED',
+        merged: true,
+        isPullRequest: true,
+      });
+      let now = 0;
+      const cache = new IssueTitleStateCache(() => now);
+      const url = 'https://github.com/o/r/pull/1';
+      await handleIssueTitle(issueRepository, cache, url);
+      now = ISSUE_TITLE_CACHE_TTL_MS * 1000;
+      await handleIssueTitle(issueRepository, cache, url);
+      expect(issueRepository.getIssueOrPullRequestState).toHaveBeenCalledTimes(
+        1,
+      );
+    });
+  });
+});