npm-cli-gh-issue-preparator 1.0.0

package/src/adapter/entry-points/cli/index.test.ts

@@ -0,0 +1,165 @@
+import { program } from './index';
+import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
+import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
+
+jest.mock('../../../domain/usecases/StartPreparationUseCase');
+jest.mock('../../../domain/usecases/NotifyFinishedIssuePreparationUseCase');
+jest.mock('../../repositories/GitHubProjectRepository');
+jest.mock('../../repositories/GitHubIssueRepository');
+jest.mock('../../repositories/NodeLocalCommandRunner');
+
+describe('CLI', () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    process.env = { ...originalEnv, GH_TOKEN: 'test-token' };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  it('should export program', () => {
+    expect(program).toBeDefined();
+  });
+
+  it('should pass correct parameters to StartPreparationUseCase', async () => {
+    const mockRun = jest.fn().mockResolvedValue(undefined);
+    const MockedStartPreparationUseCase = jest.mocked(StartPreparationUseCase);
+
+    MockedStartPreparationUseCase.mockImplementation(function (
+      this: StartPreparationUseCase,
+    ) {
+      this.run = mockRun;
+      this.maximumPreparingIssuesCount = 6;
+      return this;
+    });
+
+    await program.parseAsync([
+      'node',
+      'test',
+      'startDaemon',
+      '--projectUrl',
+      'https://github.com/test/project',
+      '--awaitingWorkspaceStatus',
+      'Awaiting',
+      '--preparationStatus',
+      'Preparing',
+      '--defaultAgentName',
+      'agent1',
+    ]);
+
+    expect(mockRun).toHaveBeenCalledTimes(1);
+    expect(mockRun).toHaveBeenCalledWith({
+      projectUrl: 'https://github.com/test/project',
+      awaitingWorkspaceStatus: 'Awaiting',
+      preparationStatus: 'Preparing',
+      defaultAgentName: 'agent1',
+    });
+  });
+
+  it('should pass correct parameters to NotifyFinishedIssuePreparationUseCase', async () => {
+    const mockRun = jest.fn().mockResolvedValue(undefined);
+    const MockedNotifyFinishedUseCase = jest.mocked(
+      NotifyFinishedIssuePreparationUseCase,
+    );
+
+    MockedNotifyFinishedUseCase.mockImplementation(function (
+      this: NotifyFinishedIssuePreparationUseCase,
+    ) {
+      this.run = mockRun;
+      return this;
+    });
+
+    await program.parseAsync([
+      'node',
+      'test',
+      'notifyFinishedIssuePreparation',
+      '--projectUrl',
+      'https://github.com/test/project',
+      '--issueUrl',
+      'https://github.com/test/issue/1',
+      '--preparationStatus',
+      'Preparing',
+      '--awaitingQualityCheckStatus',
+      'Awaiting QC',
+    ]);
+
+    expect(mockRun).toHaveBeenCalledTimes(1);
+    expect(mockRun).toHaveBeenCalledWith({
+      projectUrl: 'https://github.com/test/project',
+      issueUrl: 'https://github.com/test/issue/1',
+      preparationStatus: 'Preparing',
+      awaitingQualityCheckStatus: 'Awaiting QC',
+    });
+  });
+
+  it('should exit with error when GH_TOKEN is missing for startDaemon', async () => {
+    delete process.env.GH_TOKEN;
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    const processExitSpy = jest
+      .spyOn(process, 'exit')
+      .mockImplementation(() => {
+        throw new Error('process.exit called');
+      });
+
+    await expect(
+      program.parseAsync([
+        'node',
+        'test',
+        'startDaemon',
+        '--projectUrl',
+        'https://github.com/test/project',
+        '--awaitingWorkspaceStatus',
+        'Awaiting',
+        '--preparationStatus',
+        'Preparing',
+        '--defaultAgentName',
+        'agent1',
+      ]),
+    ).rejects.toThrow('process.exit called');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'GH_TOKEN environment variable is required',
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    consoleErrorSpy.mockRestore();
+    processExitSpy.mockRestore();
+  });
+
+  it('should exit with error when GH_TOKEN is missing for notifyFinishedIssuePreparation', async () => {
+    delete process.env.GH_TOKEN;
+    const consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    const processExitSpy = jest
+      .spyOn(process, 'exit')
+      .mockImplementation(() => {
+        throw new Error('process.exit called');
+      });
+
+    await expect(
+      program.parseAsync([
+        'node',
+        'test',
+        'notifyFinishedIssuePreparation',
+        '--projectUrl',
+        'https://github.com/test/project',
+        '--issueUrl',
+        'https://github.com/test/issue/1',
+        '--preparationStatus',
+        'Preparing',
+        '--awaitingQualityCheckStatus',
+        'Awaiting QC',
+      ]),
+    ).rejects.toThrow('process.exit called');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(
+      'GH_TOKEN environment variable is required',
+    );
+    expect(processExitSpy).toHaveBeenCalledWith(1);
+
+    consoleErrorSpy.mockRestore();
+    processExitSpy.mockRestore();
+  });
+});

package/src/adapter/entry-points/cli/index.ts

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { Command } from 'commander';
+import { StartPreparationUseCase } from '../../../domain/usecases/StartPreparationUseCase';
+import { NotifyFinishedIssuePreparationUseCase } from '../../../domain/usecases/NotifyFinishedIssuePreparationUseCase';
+import { GitHubProjectRepository } from '../../repositories/GitHubProjectRepository';
+import { GitHubIssueRepository } from '../../repositories/GitHubIssueRepository';
+import { NodeLocalCommandRunner } from '../../repositories/NodeLocalCommandRunner';
+
+type StartDaemonOptions = {
+  projectUrl: string;
+  awaitingWorkspaceStatus: string;
+  preparationStatus: string;
+  defaultAgentName: string;
+};
+
+type NotifyFinishedOptions = {
+  projectUrl: string;
+  issueUrl: string;
+  preparationStatus: string;
+  awaitingQualityCheckStatus: string;
+};
+
+const program = new Command();
+program
+  .name('npm-cli-gh-issue-preparator')
+  .description('CLI tool to prepare GitHub issues');
+
+program
+  .command('startDaemon')
+  .description('Start daemon to prepare GitHub issues')
+  .requiredOption('--projectUrl <url>', 'GitHub project URL')
+  .requiredOption(
+    '--awaitingWorkspaceStatus <status>',
+    'Status for issues awaiting workspace',
+  )
+  .requiredOption(
+    '--preparationStatus <status>',
+    'Status for issues in preparation',
+  )
+  .requiredOption('--defaultAgentName <name>', 'Default agent name')
+  .action(async (options: StartDaemonOptions) => {
+    const token = process.env.GH_TOKEN;
+    if (!token) {
+      console.error('GH_TOKEN environment variable is required');
+      process.exit(1);
+    }
+
+    const projectRepository = new GitHubProjectRepository(token);
+    const issueRepository = new GitHubIssueRepository(token);
+    const localCommandRunner = new NodeLocalCommandRunner();
+
+    const useCase = new StartPreparationUseCase(
+      projectRepository,
+      issueRepository,
+      localCommandRunner,
+    );
+
+    await useCase.run({
+      projectUrl: options.projectUrl,
+      awaitingWorkspaceStatus: options.awaitingWorkspaceStatus,
+      preparationStatus: options.preparationStatus,
+      defaultAgentName: options.defaultAgentName,
+    });
+  });
+
+program
+  .command('notifyFinishedIssuePreparation')
+  .description('Notify that issue preparation is finished')
+  .requiredOption('--projectUrl <url>', 'GitHub project URL')
+  .requiredOption('--issueUrl <url>', 'GitHub issue URL')
+  .requiredOption(
+    '--preparationStatus <status>',
+    'Status for issues in preparation',
+  )
+  .requiredOption(
+    '--awaitingQualityCheckStatus <status>',
+    'Status for issues awaiting quality check',
+  )
+  .action(async (options: NotifyFinishedOptions) => {
+    const token = process.env.GH_TOKEN;
+    if (!token) {
+      console.error('GH_TOKEN environment variable is required');
+      process.exit(1);
+    }
+
+    const projectRepository = new GitHubProjectRepository(token);
+    const issueRepository = new GitHubIssueRepository(token);
+
+    const useCase = new NotifyFinishedIssuePreparationUseCase(
+      projectRepository,
+      issueRepository,
+    );
+
+    await useCase.run({
+      projectUrl: options.projectUrl,
+      issueUrl: options.issueUrl,
+      preparationStatus: options.preparationStatus,
+      awaitingQualityCheckStatus: options.awaitingQualityCheckStatus,
+    });
+  });
+
+/* istanbul ignore next */
+if (process.argv && require.main === module) {
+  program.parse(process.argv);
+}
+
+export { program };

package/src/adapter/repositories/GitHubIssueRepository.integration.test.ts

@@ -0,0 +1,50 @@
+import dotenv from 'dotenv';
+dotenv.config();
+
+import { GitHubIssueRepository } from './GitHubIssueRepository';
+import { GitHubProjectRepository } from './GitHubProjectRepository';
+
+describe('GitHubIssueRepository Integration Test', () => {
+  const token = process.env.GH_TOKEN;
+  const projectUrl = 'https://github.com/users/HiromiShikata/projects/49';
+  const issueUrl =
+    'https://github.com/HiromiShikata/test-repository/issues/1552';
+
+  it('should update issue status from Awaiting workspace to Preparation and verify the change', async () => {
+    if (!token) {
+      throw new Error('GH_TOKEN environment variable is required');
+    }
+
+    const repository = new GitHubIssueRepository(token);
+    const projectRepository = new GitHubProjectRepository(token);
+    const project = await projectRepository.getByUrl(projectUrl);
+
+    const initialIssue = await repository.get(issueUrl, project);
+    expect(initialIssue).not.toBeNull();
+    if (!initialIssue) {
+      throw new Error('Failed to get initial issue');
+    }
+
+    initialIssue.status = 'Awaiting workspace';
+    await repository.update(initialIssue, project);
+
+    const reloadedIssue = await repository.get(issueUrl, project);
+    if (!reloadedIssue) {
+      throw new Error('Failed to get reloaded issue');
+    }
+    expect(reloadedIssue.status).toBe('Awaiting workspace');
+
+    reloadedIssue.status = 'Preparation';
+    await repository.update(reloadedIssue, project);
+
+    const verifyIssue = await repository.get(issueUrl, project);
+    expect(verifyIssue).not.toBeNull();
+    if (!verifyIssue) {
+      throw new Error('Failed to get verify issue');
+    }
+    expect(verifyIssue.status).toBe('Preparation');
+
+    verifyIssue.status = 'Awaiting workspace';
+    await repository.update(verifyIssue, project);
+  }, 60000);
+});