github-issue-tower-defence-management 1.163.0 → 1.165.0

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

@@ -45,6 +45,7 @@ const createMockProject = (overrides: Partial<Project> = {}): Project => ({
   remainingEstimationMinutes: null,
   dependedIssueUrlSeparatedByComma: null,
   completionDate50PercentConfidence: null,
+  agent: null,
   ...overrides,
 });
 
@@ -73,6 +74,7 @@ const createMockIssue = (overrides: Partial<Issue> = {}): Issue => ({
   createdAt: new Date(),
   author: '',
   closingIssueReferenceUrls: [],
+  agent: null,
   ...overrides,
 });
 
@@ -87,11 +89,14 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
   let useCase: NotifyFinishedIssuePreparationUseCase;
   let mockProjectRepository: {
     getByUrl: jest.Mock;
+    updateAgentList: jest.Mock;
   };
   let mockIssueRepository: {
     get: jest.Mock;
     update: jest.Mock;
     updateStatus: jest.Mock;
+    updateLabels: jest.Mock;
+    getOrCreateLabel: jest.Mock;
     findRelatedOpenPRs: jest.Mock;
     getStoryObjectMap: jest.Mock;
     getOpenPullRequest: jest.Mock;
@@ -99,6 +104,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     approvePullRequest: jest.Mock;
     requestChangesWithInlineComment: jest.Mock;
     setDependedIssueUrl: jest.Mock;
+    setIssueAgentField: jest.Mock;
   };
   let mockIssueCommentRepository: {
     getCommentsFromIssue: jest.Mock;
@@ -121,6 +127,7 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
 
     mockProjectRepository = {
       getByUrl: jest.fn(),
+      updateAgentList: jest.fn().mockResolvedValue([]),
     };
 
     mockIssueRepository = {
@@ -128,12 +135,15 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
       get: jest.fn(),
       update: jest.fn(),
       updateStatus: jest.fn(),
+      updateLabels: jest.fn().mockResolvedValue(undefined),
+      getOrCreateLabel: jest.fn().mockResolvedValue(undefined),
       findRelatedOpenPRs: jest.fn(),
       getOpenPullRequest: jest.fn(),
       getPullRequestChangedFilePaths: jest.fn().mockResolvedValue([]),
       approvePullRequest: jest.fn().mockResolvedValue(undefined),
       requestChangesWithInlineComment: jest.fn().mockResolvedValue(undefined),
       setDependedIssueUrl: jest.fn(),
+      setIssueAgentField: jest.fn().mockResolvedValue(undefined),
     };
 
     mockIssueCommentRepository = {
@@ -799,6 +809,237 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     );
   });
 
+  it('should add nextStepAgent label and return to Awaiting Workspace when report has nextStepAgent', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      org: 'user',
+      repo: 'repo',
+      labels: [],
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: Agent report\n```json\n{"nextStepAgent": "llm-agent:chore", "nextStep": null}\n```',
+      }),
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.getOrCreateLabel).toHaveBeenCalledWith(
+      'user',
+      'repo',
+      'llm-agent:chore',
+    );
+    expect(mockIssueRepository.updateLabels).toHaveBeenCalledWith(
+      expect.objectContaining({ labels: ['llm-agent:chore'] }),
+      ['llm-agent:chore'],
+    );
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({ status: 'Awaiting Workspace' }),
+      mockProject,
+    );
+    expect(mockIssueCommentRepository.createComment).toHaveBeenCalledWith(
+      expect.objectContaining({ url: 'https://github.com/user/repo/issues/1' }),
+      expect.stringContaining('llm-agent:chore'),
+    );
+  });
+
+  it('should preserve existing labels when adding nextStepAgent label', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      org: 'user',
+      repo: 'repo',
+      labels: ['existing-label'],
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: Agent report\n```json\n{"nextStepAgent": "llm-agent:impl", "nextStep": null}\n```',
+      }),
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.updateLabels).toHaveBeenCalledWith(
+      expect.objectContaining({
+        labels: ['existing-label', 'llm-agent:impl'],
+      }),
+      ['existing-label', 'llm-agent:impl'],
+    );
+  });
+
+  it('should not add nextStepAgent label when nextStepAgent is null', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: Agent report\n```json\n{"nextStepAgent": null, "nextStep": null}\n```',
+      }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.getOrCreateLabel).not.toHaveBeenCalled();
+    expect(mockIssueRepository.updateLabels).not.toHaveBeenCalled();
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({ status: 'Awaiting Quality Check' }),
+      mockProject,
+    );
+  });
+
+  it('should create label when nextStepAgent label does not exist in repo', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      org: 'user',
+      repo: 'repo',
+      labels: [],
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: Agent report\n```json\n{"nextStepAgent": "llm-agent:new-agent", "nextStep": null}\n```',
+      }),
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.getOrCreateLabel).toHaveBeenCalledWith(
+      'user',
+      'repo',
+      'llm-agent:new-agent',
+    );
+  });
+
+  it('should remove existing llm-agent labels and labelsAsLlmAgentName labels when adding nextStepAgent label', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+      org: 'user',
+      repo: 'repo',
+      labels: ['llm-agent:chore', 'chore', 'feature-flag'],
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: Agent report\n```json\n{"nextStepAgent": "llm-agent:impl", "nextStep": null}\n```',
+      }),
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+      labelsAsLlmAgentName: ['chore', 'accounting'],
+    });
+
+    expect(mockIssueRepository.updateLabels).toHaveBeenCalledWith(
+      expect.objectContaining({
+        labels: ['feature-flag', 'llm-agent:impl'],
+      }),
+      ['feature-flag', 'llm-agent:impl'],
+    );
+  });
+
+  it('should not add nextStepAgent label when nextStepAgent is an empty string', async () => {
+    const issue = createMockIssue({
+      url: 'https://github.com/user/repo/issues/1',
+      status: 'Preparation',
+    });
+
+    mockProjectRepository.getByUrl.mockResolvedValue(mockProject);
+    mockIssueRepository.get.mockResolvedValue(issue);
+    mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+      createMockComment({
+        content:
+          'From: :robot: Agent report\n```json\n{"nextStepAgent": "", "nextStep": null}\n```',
+      }),
+    ]);
+    mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+      {
+        url: 'https://github.com/user/repo/pull/1',
+        isConflicted: false,
+        isPassedAllCiJob: true,
+        isCiStateSuccess: true,
+        isResolvedAllReviewComments: true,
+        isBranchOutOfDate: false,
+        missingRequiredCheckNames: [],
+      },
+    ]);
+
+    await useCase.run({
+      projectUrl: 'https://github.com/users/user/projects/1',
+      issueUrl: 'https://github.com/user/repo/issues/1',
+      thresholdForAutoReject: 3,
+      workflowBlockerResolvedWebhookUrl: null,
+      allowedIssueAuthors: null,
+    });
+
+    expect(mockIssueRepository.getOrCreateLabel).not.toHaveBeenCalled();
+    expect(mockIssueRepository.updateLabels).not.toHaveBeenCalled();
+    expect(mockIssueRepository.update).toHaveBeenCalledWith(
+      expect.objectContaining({ status: 'Awaiting Quality Check' }),
+      mockProject,
+    );
+  });
+
   it('should auto-escalate to Failed Preparation after threshold rejections', async () => {
     const issue = createMockIssue({
       url: 'https://github.com/user/repo/issues/1',
@@ -3364,6 +3605,146 @@ describe('NotifyFinishedIssuePreparationUseCase', () => {
     });
   });
 
+  describe('nextStepAgent handling', () => {
+    const makeProjectWithAgent = () =>
+      createMockProject({
+        agent: {
+          name: 'Agent',
+          fieldId: 'agent-field-id',
+          options: [
+            { id: 'opt-impl', name: 'impl', color: 'GRAY', description: '' },
+          ],
+        },
+      });
+
+    it('calls setIssueAgentField with existing option ID when nextStepAgent is in last comment', async () => {
+      const issue = createMockIssue({ status: 'Preparation' });
+      const projectWithAgent = makeProjectWithAgent();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithAgent);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: agent (model)\n```json\n{"nextStep": "do something", "nextStepAgent": "impl"}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledWith(
+        'https://github.com/user/repo/issues/1',
+        projectWithAgent,
+        'opt-impl',
+      );
+    });
+
+    it('creates a new agent option and calls setIssueAgentField when nextStepAgent is not an existing option', async () => {
+      const issue = createMockIssue({ status: 'Preparation' });
+      const projectWithAgent = makeProjectWithAgent();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithAgent);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: agent (model)\n```json\n{"nextStep": "review", "nextStepAgent": "chore"}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+      mockProjectRepository.updateAgentList.mockResolvedValue([
+        { id: 'opt-impl', name: 'impl', color: 'GRAY', description: '' },
+        { id: 'opt-chore-new', name: 'chore', color: 'GRAY', description: '' },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockProjectRepository.updateAgentList).toHaveBeenCalledWith(
+        projectWithAgent,
+        expect.arrayContaining([
+          expect.objectContaining({ name: 'impl' }),
+          expect.objectContaining({ id: null, name: 'chore', color: 'GRAY' }),
+        ]),
+      );
+      expect(mockIssueRepository.setIssueAgentField).toHaveBeenCalledWith(
+        'https://github.com/user/repo/issues/1',
+        projectWithAgent,
+        'opt-chore-new',
+      );
+    });
+
+    it('does not call setIssueAgentField when nextStepAgent is absent from the last comment', async () => {
+      const issue = createMockIssue({ status: 'Preparation' });
+      const projectWithAgent = makeProjectWithAgent();
+      mockProjectRepository.getByUrl.mockResolvedValue(projectWithAgent);
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: agent (model)\n```json\n{"nextStep": null}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([
+        {
+          url: 'https://github.com/user/repo/pull/1',
+          isConflicted: false,
+          isPassedAllCiJob: true,
+          isCiStateSuccess: true,
+          isResolvedAllReviewComments: true,
+          isBranchOutOfDate: false,
+          missingRequiredCheckNames: [],
+        },
+      ]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
+      expect(mockProjectRepository.updateAgentList).not.toHaveBeenCalled();
+    });
+
+    it('does not call setIssueAgentField when project has no agent field', async () => {
+      const issue = createMockIssue({ status: 'Preparation' });
+      mockProjectRepository.getByUrl.mockResolvedValue(
+        createMockProject({ agent: null }),
+      );
+      mockIssueRepository.get.mockResolvedValue(issue);
+      mockIssueCommentRepository.getCommentsFromIssue.mockResolvedValue([
+        createMockComment({
+          content:
+            'From: :robot: agent (model)\n```json\n{"nextStep": "go", "nextStepAgent": "impl"}\n```',
+        }),
+      ]);
+      mockIssueRepository.findRelatedOpenPRs.mockResolvedValue([]);
+
+      await useCase.run({
+        projectUrl: 'https://github.com/users/user/projects/1',
+        issueUrl: 'https://github.com/user/repo/issues/1',
+        thresholdForAutoReject: 3,
+        workflowBlockerResolvedWebhookUrl: null,
+        allowedIssueAuthors: null,
+      });
+
+      expect(mockIssueRepository.setIssueAgentField).not.toHaveBeenCalled();
+    });
+  });
+
   describe('consoleTabsRepository integration', () => {
     let mockConsoleTabsRepository: {
       patchIssueTabTransition: jest.Mock;

package/src/domain/usecases/NotifyFinishedIssuePreparationUseCase.ts

@@ -25,6 +25,8 @@ import {
   ConsoleTabName,
 } from './console/GenerateConsoleListsUseCase';
 import { Issue } from '../entities/Issue';
+import { FieldOption, Project } from '../entities/Project';
+import { normalizeProjectFieldName } from '../entities/ProjectFieldName';
 
 export class IssueNotFoundError extends Error {
   constructor(issueUrl: string) {
@@ -52,12 +54,17 @@ export class NotifyFinishedIssuePreparationUseCase {
   private readonly changeTargetPullRequestApprover: ChangeTargetPullRequestApprover;
 
   constructor(
-    private readonly projectRepository: Pick<ProjectRepository, 'getByUrl'>,
+    private readonly projectRepository: Pick<
+      ProjectRepository,
+      'getByUrl' | 'updateAgentList'
+    >,
     private readonly issueRepository: Pick<
       IssueRepository,
       | 'get'
       | 'update'
       | 'updateStatus'
+      | 'updateLabels'
+      | 'getOrCreateLabel'
       | 'findRelatedOpenPRs'
       | 'getStoryObjectMap'
       | 'getOpenPullRequest'
@@ -65,6 +72,7 @@ export class NotifyFinishedIssuePreparationUseCase {
       | 'approvePullRequest'
       | 'requestChangesWithInlineComment'
       | 'setDependedIssueUrl'
+      | 'setIssueAgentField'
     >,
     private readonly issueCommentRepository: Pick<
       IssueCommentRepository,
@@ -91,6 +99,7 @@ export class NotifyFinishedIssuePreparationUseCase {
     labelsAsLlmAgentName?: string[] | null;
     labelsNotRequiringPullRequest?: string[] | null;
     changeTargetPathAliases?: Record<string, string> | null;
+    agents?: string[] | null;
   }): Promise<void> => {
     const project = await this.projectRepository.getByUrl(params.projectUrl);
 
@@ -193,6 +202,55 @@ export class NotifyFinishedIssuePreparationUseCase {
     const isTrustedAuthor = (author: string): boolean =>
       this.isAuthorTrusted(author, params.allowedIssueAuthors ?? null);
 
+    const lastTrustedBotComment = [...comments]
+      .reverse()
+      .find(
+        (c) =>
+          isTrustedAuthor(c.author) && c.content.startsWith('From: :robot:'),
+      );
+    const nextStepAgent = lastTrustedBotComment
+      ? this.extractNextStepAgent(lastTrustedBotComment.content)
+      : null;
+    if (nextStepAgent !== null) {
+      const agentOptionId = await this.ensureAgentOptionAndGetId(
+        project,
+        nextStepAgent,
+      );
+      if (agentOptionId) {
+        await this.issueRepository.setIssueAgentField(
+          params.issueUrl,
+          project,
+          agentOptionId,
+        );
+      }
+      await this.issueRepository.getOrCreateLabel(
+        issue.org,
+        issue.repo,
+        nextStepAgent,
+      );
+      const agentLabels = params.labelsAsLlmAgentName ?? [];
+      const filteredLabels = issue.labels.filter(
+        (label) =>
+          !label.startsWith('llm-agent:') && !agentLabels.includes(label),
+      );
+      const updatedLabels = [...new Set([...filteredLabels, nextStepAgent])];
+      issue.labels = updatedLabels;
+      issue.status = AWAITING_WORKSPACE_STATUS_NAME;
+      await this.issueRepository.update(issue, project);
+      await this.issueRepository.updateStatus(
+        project,
+        issue,
+        awaitingWorkspaceStatusOption.id,
+      );
+      await this.issueRepository.updateLabels(issue, updatedLabels);
+      await this.patchConsoleTab(issue);
+      await this.issueCommentRepository.createComment(
+        issue,
+        `Next step agent: ${nextStepAgent}`,
+      );
+      return;
+    }
+
     const { rejections, approvedPrUrl } = await this.collectRejections(
       issue,
       comments,
@@ -480,6 +538,64 @@ export class NotifyFinishedIssuePreparationUseCase {
     return null;
   };
 
+  private extractNextStepAgent = (body: string): string | null => {
+    const reportMatch = body.match(/```json\n([\s\S]*?)\n```/);
+    if (!reportMatch || reportMatch.length < 2) {
+      return null;
+    }
+    let reportJson: unknown;
+    try {
+      reportJson = JSON.parse(reportMatch[1]);
+    } catch (error) {
+      console.warn(
+        'Invalid JSON in report body while checking nextStepAgent:',
+        error,
+      );
+      return null;
+    }
+    if (typeof reportJson !== 'object' || reportJson === null) {
+      return null;
+    }
+    if (!('nextStepAgent' in reportJson)) {
+      return null;
+    }
+    const value = Reflect.get(reportJson, 'nextStepAgent');
+    if (typeof value !== 'string' || value.trim() === '') {
+      return null;
+    }
+    return value.trim();
+  };
+
+  private ensureAgentOptionAndGetId = async (
+    project: Project,
+    agentName: string,
+  ): Promise<string | null> => {
+    if (!project.agent) {
+      return null;
+    }
+    const normalizedTarget = normalizeProjectFieldName(agentName);
+    const existing = project.agent.options.find(
+      (o) => normalizeProjectFieldName(o.name) === normalizedTarget,
+    );
+    if (existing) {
+      return existing.id;
+    }
+    const mergedOptions: (Omit<FieldOption, 'id'> & {
+      id: FieldOption['id'] | null;
+    })[] = [
+      ...project.agent.options.map((o) => ({ ...o })),
+      { id: null, name: agentName, color: 'GRAY' as const, description: '' },
+    ];
+    const updatedOptions = await this.projectRepository.updateAgentList(
+      project,
+      mergedOptions,
+    );
+    const created = updatedOptions.find(
+      (o) => normalizeProjectFieldName(o.name) === normalizedTarget,
+    );
+    return created?.id ?? null;
+  };
+
   private patchConsoleTab = async (issue: Issue): Promise<void> => {
     if (!this.consoleTabsRepository) return;
     const targetTabName = this.resolveConsoleTargetTab(issue.status ?? '');

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

@@ -237,6 +237,7 @@ describe('NotifySilentLiveSessionsUseCase', () => {
     createdAt: now,
     author: 'HiromiShikata',
     closingIssueReferenceUrls: [],
+    agent: null,
     ...overrides,
   });